Datasets:

---

docz1105

/

ComBack

like 9

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

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

[ "Dcpu16" ]

[]

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

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

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

[]

[ "<s>", "static", "rtx_insn", "*", "emit_sp_adjust", "(", "int", "offset", ",", "int", "*", "next_scratch_regno", ",", "bool", "frame_related", ",", "rtx", "reg_notes", ")", "{", "rtx", "to_add", ";", "rtx", "imm_rtx", "=", "gen_int_si", "(", "offset", ")", ";", "rtx_insn", "*", "insn", ";", "if", "(", "satisfies_constraint_J", "(", "imm_rtx", ")", ")", "{", "to_add", "=", "imm_rtx", ";", "}", "else", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "(", "*", "next_scratch_regno", ")", "--", ")", ";", "tilepro_expand_set_const32", "(", "tmp", ",", "imm_rtx", ")", ";", "to_add", "=", "tmp", ";", "}", "insn", "=", "emit_insn", "(", "gen_sp_adjust", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "to_add", ")", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "reg_notes", ";", "if", "(", "frame_related", ")", "{", "rtx", "real", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "imm_rtx", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "real", ")", ";", "}", "return", "insn", ";", "}", "</s>" ]

[ "This", "emits", "code", "for", "'sp", "+=", "offset", "'", ".", "The", "ABI", "only", "allows", "us", "to", "modify", "'sp", "'", "in", "a", "single", "'addi", "'", "or", "'addli", "'", ",", "so", "the", "backtracer", "understands", "it", ".", "Larger", "amounts", "can", "not", "use", "those", "instructions", ",", "so", "are", "added", "by", "placing", "the", "offset", "into", "a", "large", "register", "and", "using", "'add", "'", ".", "This", "happens", "after", "reload", ",", "so", "we", "need", "to", "expand", "it", "ourselves", "." ]

[ "tilepro", "1" ]

[]

[ "<s>", "const", "char", "*", "Z80TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "Z80ISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "Z80ISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "Z80ISD", "::", "Wrapper", ":", "return", "\"Z80ISD::Wrapper\"", ";", "case", "Z80ISD", "::", "RLC", ":", "return", "\"Z80ISD::RLC\"", ";", "case", "Z80ISD", "::", "RRC", ":", "return", "\"Z80ISD::RRC\"", ";", "case", "Z80ISD", "::", "RL", ":", "return", "\"Z80ISD::RL\"", ";", "case", "Z80ISD", "::", "RR", ":", "return", "\"Z80ISD::RR\"", ";", "case", "Z80ISD", "::", "SLA", ":", "return", "\"Z80ISD::SLA\"", ";", "case", "Z80ISD", "::", "SRA", ":", "return", "\"Z80ISD::SRA\"", ";", "case", "Z80ISD", "::", "SRL", ":", "return", "\"Z80ISD::SRL\"", ";", "case", "Z80ISD", "::", "INC", ":", "return", "\"Z80ISD::INC\"", ";", "case", "Z80ISD", "::", "DEC", ":", "return", "\"Z80ISD::DEC\"", ";", "case", "Z80ISD", "::", "ADD", ":", "return", "\"Z80ISD::ADD\"", ";", "case", "Z80ISD", "::", "ADC", ":", "return", "\"Z80ISD::ADC\"", ";", "case", "Z80ISD", "::", "SUB", ":", "return", "\"Z80ISD::SUB\"", ";", "case", "Z80ISD", "::", "SBC", ":", "return", "\"Z80ISD::SBC\"", ";", "case", "Z80ISD", "::", "AND", ":", "return", "\"Z80ISD::AND\"", ";", "case", "Z80ISD", "::", "XOR", ":", "return", "\"Z80ISD::XOR\"", ";", "case", "Z80ISD", "::", "OR", ":", "return", "\"Z80ISD::OR\"", ";", "case", "Z80ISD", "::", "CP", ":", "return", "\"Z80ISD::CP\"", ";", "case", "Z80ISD", "::", "TST", ":", "return", "\"Z80ISD::TST\"", ";", "case", "Z80ISD", "::", "MLT", ":", "return", "\"Z80ISD::MLT\"", ";", "case", "Z80ISD", "::", "SEXT", ":", "return", "\"Z80ISD::SEXT\"", ";", "case", "Z80ISD", "::", "CALL", ":", "return", "\"Z80ISD::CALL\"", ";", "case", "Z80ISD", "::", "RET_FLAG", ":", "return", "\"Z80ISD::RET_FLAG\"", ";", "case", "Z80ISD", "::", "RETN_FLAG", ":", "return", "\"Z80ISD::RETN_FLAG\"", ";", "case", "Z80ISD", "::", "RETI_FLAG", ":", "return", "\"Z80ISD::RETI_FLAG\"", ";", "case", "Z80ISD", "::", "TC_RETURN", ":", "return", "\"Z80ISD::TC_RETURN\"", ";", "case", "Z80ISD", "::", "BRCOND", ":", "return", "\"Z80ISD::BRCOND\"", ";", "case", "Z80ISD", "::", "SELECT", ":", "return", "\"Z80ISD::SELECT\"", ";", "case", "Z80ISD", "::", "POP", ":", "return", "\"Z80ISD::POP\"", ";", "case", "Z80ISD", "::", "PUSH", ":", "return", "\"Z80ISD::PUSH\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "Z80ISD::NodeType", "Z80ISD::FIRST_NUMBER", "Z80ISD::Wrapper", "\"Z80ISD::Wrapper\"", "Z80ISD::RLC", "\"Z80ISD::RLC\"", "Z80ISD::RRC", "\"Z80ISD::RRC\"", "Z80ISD::RL", "\"Z80ISD::RL\"", "Z80ISD::RR", "\"Z80ISD::RR\"", "Z80ISD::SLA", "\"Z80ISD::SLA\"", "Z80ISD::SRA", "\"Z80ISD::SRA\"", "Z80ISD::SRL", "\"Z80ISD::SRL\"", "Z80ISD::INC", "\"Z80ISD::INC\"", "Z80ISD::DEC", "\"Z80ISD::DEC\"", "Z80ISD::ADD", "\"Z80ISD::ADD\"", "Z80ISD::ADC", "\"Z80ISD::ADC\"", "Z80ISD::SUB", "\"Z80ISD::SUB\"", "Z80ISD::SBC", "\"Z80ISD::SBC\"", "Z80ISD::AND", "\"Z80ISD::AND\"", "Z80ISD::XOR", "\"Z80ISD::XOR\"", "Z80ISD::OR", "\"Z80ISD::OR\"", "Z80ISD::CP", "\"Z80ISD::CP\"", "Z80ISD::TST", "\"Z80ISD::TST\"", "Z80ISD::MLT", "\"Z80ISD::MLT\"", "Z80ISD::SEXT", "\"Z80ISD::SEXT\"", "Z80ISD::CALL", "\"Z80ISD::CALL\"", "Z80ISD::RET_FLAG", "\"Z80ISD::RET_FLAG\"", "Z80ISD::RETN_FLAG", "\"Z80ISD::RETN_FLAG\"", "Z80ISD::RETI_FLAG", "\"Z80ISD::RETI_FLAG\"", "Z80ISD::TC_RETURN", "\"Z80ISD::TC_RETURN\"", "Z80ISD::BRCOND", "\"Z80ISD::BRCOND\"", "Z80ISD::SELECT", "\"Z80ISD::SELECT\"", "Z80ISD::POP", "\"Z80ISD::POP\"", "Z80ISD::PUSH", "\"Z80ISD::PUSH\"" ]

[]

[ "<s>", "static", "void", "ia64_set_sched_flags", "(", "spec_info_t", "spec_info", ")", "{", "unsigned", "int", "*", "flags", "=", "&", "(", "current_sched_info", "->", "flags", ")", ";", "if", "(", "*", "flags", "&", "SCHED_RGN", "||", "*", "flags", "&", "SCHED_EBB", "||", "*", "flags", "&", "SEL_SCHED", ")", "{", "int", "mask", "=", "0", ";", "if", "(", "(", "mflag_sched_br_data_spec", "&&", "!", "reload_completed", "&&", "optimize", ">", "0", ")", "||", "(", "mflag_sched_ar_data_spec", "&&", "reload_completed", ")", ")", "{", "mask", "|=", "BEGIN_DATA", ";", "if", "(", "!", "sel_sched_p", "(", ")", "&&", "(", "(", "mflag_sched_br_in_data_spec", "&&", "!", "reload_completed", ")", "||", "(", "mflag_sched_ar_in_data_spec", "&&", "reload_completed", ")", ")", ")", "mask", "|=", "BE_IN_DATA", ";", "}", "if", "(", "mflag_sched_control_spec", "&&", "(", "!", "sel_sched_p", "(", ")", "||", "reload_completed", ")", ")", "{", "mask", "|=", "BEGIN_CONTROL", ";", "if", "(", "!", "sel_sched_p", "(", ")", "&&", "mflag_sched_in_control_spec", ")", "mask", "|=", "BE_IN_CONTROL", ";", "}", "spec_info", "->", "mask", "=", "mask", ";", "if", "(", "mask", ")", "{", "*", "flags", "|=", "USE_DEPS_LIST", "|", "DO_SPECULATION", ";", "if", "(", "mask", "&", "BE_IN_SPEC", ")", "*", "flags", "|=", "NEW_BBS", ";", "spec_info", "->", "flags", "=", "0", ";", "if", "(", "(", "mask", "&", "CONTROL_SPEC", ")", "&&", "sel_sched_p", "(", ")", "&&", "mflag_sel_sched_dont_check_control_spec", ")", "spec_info", "->", "flags", "|=", "SEL_SCHED_SPEC_DONT_CHECK_CONTROL", ";", "if", "(", "sched_verbose", ">=", "1", ")", "spec_info", "->", "dump", "=", "sched_dump", ";", "else", "spec_info", "->", "dump", "=", "0", ";", "if", "(", "mflag_sched_count_spec_in_critical_path", ")", "spec_info", "->", "flags", "|=", "COUNT_SPEC_IN_CRITICAL_PATH", ";", "}", "}", "else", "spec_info", "->", "mask", "=", "0", ";", "}", "</s>" ]

[ "Provide", "information", "about", "speculation", "capabilities", "." ]

[ "ia64", "0", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "getTargetMachine", "(", ")", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "unsigned", "NativeWidth", "=", "Subtarget", ".", "is64Bit", "(", ")", "?", "64", ":", "32", ";", "const", "Type", "*", "MemType", "=", "AI", "->", "getType", "(", ")", ";", "if", "(", "MemType", "->", "getPrimitiveSizeInBits", "(", ")", ">", "NativeWidth", ")", "return", "needsCmpXchgNb", "(", "MemType", ")", ";", "AtomicRMWInst", "::", "BinOp", "Op", "=", "AI", "->", "getOperation", "(", ")", ";", "switch", "(", "Op", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown atomic operation\"", ")", ";", "case", "AtomicRMWInst", "::", "Xchg", ":", "case", "AtomicRMWInst", "::", "Add", ":", "case", "AtomicRMWInst", "::", "Sub", ":", "return", "false", ";", "case", "AtomicRMWInst", "::", "Or", ":", "case", "AtomicRMWInst", "::", "And", ":", "case", "AtomicRMWInst", "::", "Xor", ":", "return", "!", "AI", "->", "use_empty", "(", ")", ";", "case", "AtomicRMWInst", "::", "Nand", ":", "case", "AtomicRMWInst", "::", "Max", ":", "case", "AtomicRMWInst", "::", "Min", ":", "case", "AtomicRMWInst", "::", "UMax", ":", "case", "AtomicRMWInst", "::", "UMin", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

[ "X86", "X86", "X86", "X86", "64", "32", "\"Unknown atomic operation\"" ]

[]

[ "<s>", "static", "int", "microblaze_version_to_int", "(", "const", "char", "*", "version", ")", "{", "const", "char", "*", "p", ",", "*", "v", ";", "const", "char", "*", "tmpl", "=", "\"vXX.YY.Z\"", ";", "int", "iver", "=", "0", ";", "p", "=", "version", ";", "v", "=", "tmpl", ";", "while", "(", "*", "p", ")", "{", "if", "(", "*", "v", "==", "'X'", ")", "{", "if", "(", "*", "p", "==", "'.'", ")", "{", "v", "++", ";", "}", "else", "{", "if", "(", "!", "(", "*", "p", ">=", "'0'", "&&", "*", "p", "<=", "'9'", ")", ")", "return", "-", "1", ";", "iver", "+=", "(", "int", ")", "(", "*", "p", "-", "'0'", ")", ";", "iver", "*=", "10", ";", "}", "}", "else", "if", "(", "*", "v", "==", "'Y'", ")", "{", "if", "(", "!", "(", "*", "p", ">=", "'0'", "&&", "*", "p", "<=", "'9'", ")", ")", "return", "-", "1", ";", "iver", "+=", "(", "int", ")", "(", "*", "p", "-", "'0'", ")", ";", "iver", "*=", "10", ";", "}", "else", "if", "(", "*", "v", "==", "'Z'", ")", "{", "if", "(", "!", "(", "*", "p", ">=", "'a'", "&&", "*", "p", "<=", "'z'", ")", ")", "return", "-", "1", ";", "iver", "*=", "10", ";", "iver", "+=", "(", "int", ")", "(", "*", "p", "-", "'a'", ")", ";", "}", "else", "{", "if", "(", "*", "p", "!=", "*", "v", ")", "return", "-", "1", ";", "}", "v", "++", ";", "p", "++", ";", "}", "if", "(", "*", "p", ")", "return", "-", "1", ";", "return", "iver", ";", "}", "</s>" ]

[ "Convert", "a", "version", "number", "of", "the", "form", "``", "vX.YY.Z", "''", "to", "an", "integer", "encoding", "for", "easier", "range", "comparison", "." ]

[ "microblaze", "\"vXX.YY.Z\"", "0", "1", "10", "1", "10", "1", "10", "1", "1" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "ARMBaseInstrInfo", "::", "insertOutlinedCall", "(", "Module", "&", "M", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "It", ",", "MachineFunction", "&", "MF", ",", "const", "outliner", "::", "Candidate", "&", "C", ")", "const", "{", "MachineInstrBuilder", "MIB", ";", "MachineBasicBlock", "::", "iterator", "CallPt", ";", "unsigned", "Opc", ";", "bool", "isThumb", "=", "Subtarget", ".", "isThumb", "(", ")", ";", "if", "(", "C", ".", "CallConstructionID", "==", "MachineOutlinerTailCall", ")", "{", "Opc", "=", "isThumb", "?", "Subtarget", ".", "isTargetMachO", "(", ")", "?", "ARM", "::", "tTAILJMPd", ":", "ARM", "::", "tTAILJMPdND", ":", "ARM", "::", "TAILJMPd", ";", "MIB", "=", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ")", ";", "if", "(", "isThumb", ")", "MIB", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "It", "=", "MBB", ".", "insert", "(", "It", ",", "MIB", ")", ";", "return", "It", ";", "}", "Opc", "=", "isThumb", "?", "ARM", "::", "tBL", ":", "ARM", "::", "BL", ";", "MachineInstrBuilder", "CallMIB", "=", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ";", "if", "(", "isThumb", ")", "CallMIB", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "CallMIB", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ")", ";", "It", "=", "MBB", ".", "insert", "(", "It", ",", "CallMIB", ")", ";", "return", "It", ";", "}", "</s>" ]

[ "Insert", "a", "call", "to", "an", "outlined", "function", "into", "the", "program", "." ]

[ "ARM", "ARM", "ARM::tTAILJMPd", "ARM::tTAILJMPdND", "ARM::TAILJMPd", "ARMCC::AL", "ARM::tBL", "ARM::BL", "ARMCC::AL" ]

[]

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

[ "Implementation", "of", "the", "SCEVPredicate", "interface", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "rtx", "ix86_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "omode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "machine_mode", "mode", "=", "omode", ";", "HOST_WIDE_INT", "bytes", ",", "words", ";", "rtx", "arg", ";", "if", "(", "!", "cum", "->", "caller", "&&", "cfun", "->", "machine", "->", "func_type", "!=", "TYPE_NORMAL", ")", "{", "gcc_assert", "(", "type", "!=", "NULL_TREE", ")", ";", "if", "(", "POINTER_TYPE_P", "(", "type", ")", ")", "{", "gcc_assert", "(", "TYPE_MODE", "(", "type", ")", "==", "Pmode", ")", ";", "if", "(", "cfun", "->", "machine", "->", "func_type", "==", "TYPE_INTERRUPT", ")", "arg", "=", "plus_constant", "(", "Pmode", ",", "arg_pointer_rtx", ",", "-", "UNITS_PER_WORD", ")", ";", "else", "arg", "=", "arg_pointer_rtx", ";", "}", "else", "{", "gcc_assert", "(", "cfun", "->", "machine", "->", "func_type", "==", "TYPE_EXCEPTION", "&&", "TREE_CODE", "(", "type", ")", "==", "INTEGER_TYPE", "&&", "TYPE_MODE", "(", "type", ")", "==", "word_mode", ")", ";", "arg", "=", "gen_rtx_MEM", "(", "word_mode", ",", "plus_constant", "(", "Pmode", ",", "arg_pointer_rtx", ",", "-", "UNITS_PER_WORD", ")", ")", ";", "}", "return", "arg", ";", "}", "if", "(", "(", "type", "&&", "POINTER_BOUNDS_TYPE_P", "(", "type", ")", ")", "||", "POINTER_BOUNDS_MODE_P", "(", "mode", ")", ")", "{", "if", "(", "cum", "->", "bnds_in_bt", ")", "arg", "=", "NULL", ";", "else", "if", "(", "cum", "->", "bnd_regno", "<=", "LAST_BND_REG", ")", "arg", "=", "gen_rtx_REG", "(", "BNDmode", ",", "cum", "->", "bnd_regno", ")", ";", "else", "arg", "=", "GEN_INT", "(", "cum", "->", "bnd_regno", "-", "LAST_BND_REG", "-", "1", ")", ";", "return", "arg", ";", "}", "if", "(", "mode", "==", "BLKmode", ")", "bytes", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "bytes", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "words", "=", "CEIL", "(", "bytes", ",", "UNITS_PER_WORD", ")", ";", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "mode", "=", "type_natural_mode", "(", "type", ",", "cum", ",", "false", ")", ";", "if", "(", "TARGET_64BIT", ")", "{", "enum", "calling_abi", "call_abi", "=", "cum", "?", "cum", "->", "call_abi", ":", "ix86_abi", ";", "if", "(", "call_abi", "==", "MS_ABI", ")", "arg", "=", "function_arg_ms_64", "(", "cum", ",", "mode", ",", "omode", ",", "named", ",", "bytes", ")", ";", "else", "arg", "=", "function_arg_64", "(", "cum", ",", "mode", ",", "omode", ",", "type", ",", "named", ")", ";", "}", "else", "arg", "=", "function_arg_32", "(", "cum", ",", "mode", ",", "omode", ",", "type", ",", "bytes", ",", "words", ")", ";", "return", "arg", ";", "}", "</s>" ]

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

[ "i386", "1" ]

[]

[ "<s>", "void", "MOSInstructionSelector", "::", "constrainOperandRegClass", "(", "MachineOperand", "&", "RegMO", ",", "const", "TargetRegisterClass", "&", "RegClass", ")", "{", "MachineInstr", "&", "MI", "=", "*", "RegMO", ".", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getMF", "(", ")", "->", "getRegInfo", "(", ")", ";", "RegMO", ".", "setReg", "(", "llvm", "::", "constrainOperandRegClass", "(", "*", "MF", ",", "TRI", ",", "MRI", ",", "TII", ",", "RBI", ",", "MI", ",", "RegClass", ",", "RegMO", ")", ")", ";", "}", "</s>" ]

[ "Try", "to", "constrain", "Op", "so", "that", "it", "is", "usable", "by", "argument", "OpNum", "of", "the", "provided", "MCInstrDesc", "." ]

[ "MOS", "MOS" ]

[]

[ "<s>", "bool", "hasAddressTaken", "(", ")", "const", "{", "if", "(", "MBB", ")", "return", "MBB", "->", "hasAddressTaken", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Test", "whether", "this", "block", "is", "used", "as", "something", "other", "than", "the", "target", "of", "a", "terminator", ",", "exception-handling", "target", ",", "or", "jump", "table", "." ]

[ "Patmos" ]

[]

[ "<s>", "void", "setShrinkWrapDisabled", "(", "bool", "U", ")", "{", "ShrinkWrapDisabled", "=", "U", ";", "}", "</s>" ]

[ "We", "certainly", "do", "n't", "want", "to", "shrink", "wrap", "functions", "if", "we", "'ve", "emitted", "a", "MovePCtoLR8", "as", "that", "has", "to", "go", "into", "the", "entry", ",", "so", "the", "prologue", "definitely", "has", "to", "go", "into", "the", "entry", "block", "." ]

[ "PowerPC" ]

[]

[ "<s>", "const", "Triple", "&", "getTargetTriple", "(", ")", "const", "{", "return", "TargetTriple", ";", "}", "</s>" ]

[ "Get", "the", "target", "triple", "which", "is", "a", "string", "describing", "the", "target", "host", "." ]

[ "ARM" ]

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "getPassName", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "skipModule", "(", "M", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "PromotionCacheTy", "PromotionCache", ";", "for", "(", "auto", "&", "MF", ":", "M", ")", "{", "Changed", "|=", "runOnFunction", "(", "MF", ",", "PromotionCache", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", ",", "unsigned", ",", "MachineMemOperand", "::", "Flags", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "DisablePPCUnaligned", ")", "return", "false", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "if", "(", "VT", ".", "isFloatingPoint", "(", ")", "&&", "!", "Subtarget", ".", "allowsUnalignedFPAccess", "(", ")", ")", "return", "false", ";", "if", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "isVector", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "{", "if", "(", "VT", "!=", "MVT", "::", "v2f64", "&&", "VT", "!=", "MVT", "::", "v2i64", "&&", "VT", "!=", "MVT", "::", "v4f32", "&&", "VT", "!=", "MVT", "::", "v4i32", ")", "return", "false", ";", "}", "else", "{", "return", "false", ";", "}", "}", "if", "(", "VT", "==", "MVT", "::", "ppcf128", ")", "return", "false", ";", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "PowerPC", "PPC", "PPC", "MVT::v2f64", "MVT::v2i64", "MVT::v4f32", "MVT::v4i32", "MVT::ppcf128" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"SI Lower literal constants pass\"", ";", "}", "</s>" ]

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

[ "R600", "\"SI Lower literal constants pass\"" ]

[]

[ "<s>", "void", "tilegx_emit_conditional_branch", "(", "rtx", "operands", "[", "]", ",", "machine_mode", "cmp_mode", ")", "{", "rtx", "cmp_rtx", "=", "tilegx_emit_cc_test", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ",", "cmp_mode", ",", "false", ")", ";", "rtx", "branch_rtx", "=", "gen_rtx_SET", "(", "pc_rtx", ",", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "cmp_rtx", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "operands", "[", "3", "]", ")", ",", "pc_rtx", ")", ")", ";", "emit_jump_insn", "(", "branch_rtx", ")", ";", "}", "</s>" ]

[ "Generate", "the", "comparison", "for", "a", "conditional", "branch", "." ]

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

[]

[ "<s>", "const", "char", "*", "WebAssemblyTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "static_cast", "<", "WebAssemblyISD", "::", "NodeType", ">", "(", "Opcode", ")", ")", "{", "case", "WebAssemblyISD", "::", "FIRST_NUMBER", ":", "case", "WebAssemblyISD", "::", "FIRST_MEM_OPCODE", ":", "break", ";", "case", "WebAssemblyISD", "::", "NODE", ":", "\\", "return", "\"WebAssemblyISD::\"", "#", "NODE", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssemblyISD::NodeType", "WebAssemblyISD::FIRST_NUMBER", "WebAssemblyISD::FIRST_MEM_OPCODE", "WebAssemblyISD::NODE", "\"WebAssemblyISD::\"" ]

[]

[ "<s>", "void", "gen_shifty_hi_op", "(", "int", "code", ",", "rtx", "*", "operands", ")", "{", "int", "value", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "int", "max", ",", "i", ";", "void", "(", "*", "gen_fun", ")", "(", "int", ",", "int", ",", "rtx", ")", ";", "value", "&=", "31", ";", "if", "(", "value", "==", "0", ")", "{", "emit_insn", "(", "gen_nop", "(", ")", ")", ";", "return", ";", "}", "gen_fun", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", "==", "HImode", "?", "gen_ashift_hi", ":", "gen_ashift", ";", "if", "(", "code", "==", "ASHIFT", ")", "{", "max", "=", "ext_ashl_lshr_seq", "[", "value", "]", ".", "insn_count", ";", "for", "(", "i", "=", "0", ";", "i", "<", "max", ";", "i", "++", ")", "gen_fun", "(", "code", ",", "ext_ashl_lshr_seq", "[", "value", "]", ".", "amount", "[", "i", "]", ",", "operands", "[", "0", "]", ")", ";", "}", "else", "for", "(", "i", "=", "ext_ashl_lshr_seq", "[", "value", "]", ".", "insn_count", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "gen_fun", "(", "code", ",", "ext_ashl_lshr_seq", "[", "value", "]", ".", "amount", "[", "i", "]", ",", "operands", "[", "0", "]", ")", ";", "}", "</s>" ]

[ "Same", "as", "above", ",", "but", "optimized", "for", "values", "where", "the", "topmost", "bits", "do", "n't", "matter", "." ]

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

[]

[ "<s>", "void", "HexagonShuffler", "::", "reset", "(", ")", "{", "Packet", ".", "clear", "(", ")", ";", "BundleFlags", "=", "0", ";", "}", "</s>" ]

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

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

[]

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

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

[ "Mips", "Mips", "1", "\"getBranchTargetOpValueMM expects only expressions or immediates\"", "0", "Mips", "0" ]

[]

[ "<s>", "static", "tls_model", "or1k_tls_symbolic_operand", "(", "rtx", "op", ")", "{", "rtx", "sym", ",", "addend", ";", "split_const", "(", "op", ",", "&", "sym", ",", "&", "addend", ")", ";", "if", "(", "SYMBOL_REF_P", "(", "sym", ")", ")", "return", "SYMBOL_REF_TLS_MODEL", "(", "sym", ")", ";", "return", "TLS_MODEL_NONE", ";", "}", "</s>" ]

[ "Return", "the", "TLS", "type", "for", "TLS", "symbols", ",", "0", "otherwise", "." ]

[ "or1k" ]

[]

[ "<s>", "rtx", "frv_find_base_term", "(", "rtx", "x", ")", "{", "struct", "frv_unspec", "unspec", ";", "if", "(", "frv_const_unspec_p", "(", "x", ",", "&", "unspec", ")", "&&", "frv_small_data_reloc_p", "(", "unspec", ".", "symbol", ",", "unspec", ".", "reloc", ")", ")", "return", "plus_constant", "(", "Pmode", ",", "unspec", ".", "symbol", ",", "unspec", ".", "offset", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "Implement", "FIND_BASE_TERM", ".", "See", "whether", "ORIG_X", "represents", "#", "gprel12", "(", "foo", ")", "or", "#", "gotoff12", "(", "foo", ")", "for", "some", "small", "data", "symbol", "foo", ".", "If", "so", ",", "return", "foo", ",", "otherwise", "return", "ORIG_X", "." ]

[ "frv" ]

[]

[ "<s>", "bool", "SIFixWWMLiveness", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"SIFixWWMLiveness: function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "bool", "Modified", "=", "false", ";", "LIS", "=", "getAnalysisIfAvailable", "<", "LiveIntervals", ">", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "DomTree", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "LoopInfo", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "EXIT_WWM", ")", "WWMs", ".", "push_back", "(", "&", "MI", ")", ";", "else", "{", "for", "(", "MachineOperand", "&", "DefOpnd", ":", "MI", ".", "defs", "(", ")", ")", "{", "if", "(", "DefOpnd", ".", "isReg", "(", ")", ")", "{", "unsigned", "Reg", "=", "DefOpnd", ".", "getReg", "(", ")", ";", "if", "(", "TRI", "->", "isVGPR", "(", "*", "MRI", ",", "Reg", ")", ")", "processDef", "(", "DefOpnd", ")", ";", "}", "}", "}", "}", "}", "if", "(", "!", "WWMs", ".", "empty", "(", ")", ")", "{", "for", "(", "auto", "ThenDef", ":", "ThenDefs", ")", "Modified", "|=", "processThenDef", "(", "ThenDef", ")", ";", "for", "(", "auto", "LoopExitDef", ":", "LoopExitDefs", ")", "Modified", "|=", "processLoopExitDef", "(", "LoopExitDef", ".", "first", ",", "LoopExitDef", ".", "second", ")", ";", "for", "(", "auto", "LoopPhiDef", ":", "LoopPhiDefs", ")", "Modified", "|=", "processLoopPhiDef", "(", "LoopPhiDef", ".", "first", ",", "LoopPhiDef", ".", "second", ")", ";", "}", "WWMs", ".", "clear", "(", ")", ";", "ThenDefs", ".", "clear", "(", ")", ";", "LoopExitDefs", ".", "clear", "(", ")", ";", "LoopPhiDefs", ".", "clear", "(", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "\"SIFixWWMLiveness: function \"", "\"\\n\"", "AMDGPU::EXIT_WWM" ]

[]

[ "<s>", "AMDGPUSubtarget", "&", "AMDGPUSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "GPU", ",", "StringRef", "FS", ")", "{", "SmallString", "<", "256", ">", "FullFS", "(", "\"+promote-alloca,+fp64-denormals,\"", ")", ";", "if", "(", "isAmdHsaOS", "(", ")", ")", "FullFS", "+=", "\"+flat-for-global,\"", ";", "FullFS", "+=", "FS", ";", "ParseSubtargetFeatures", "(", "GPU", ",", "FullFS", ")", ";", "if", "(", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "FP32Denormals", "=", "false", ";", "FP64Denormals", "=", "false", ";", "}", "return", "*", "this", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "256", "\"+promote-alloca,+fp64-denormals,\"", "\"+flat-for-global,\"", "AMDGPU" ]

[]

[ "<s>", "BitVector", "HSAILRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "HSAILMachineFunctionInfo", "*", "MFI", "=", "const_cast", "<", "HSAILMachineFunctionInfo", "*", ">", "(", "MF", ".", "getInfo", "<", "HSAILMachineFunctionInfo", ">", "(", ")", ")", ";", "unsigned", "NumSlotsTotal", "=", "HSAIL", "::", "GPR64RegClass", ".", "getNumRegs", "(", ")", ";", "unsigned", "RegSlots", "=", "NumSlotsTotal", "/", "2", ";", "if", "(", "MFI", "->", "getRegisterPartitioning", "(", ")", "==", "0", ")", "{", "const", "MachineRegisterInfo", "&", "RI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "unsigned", "rc32", "=", "0", ",", "rc64", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RI", ".", "getNumVirtRegs", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "switch", "(", "RI", ".", "getRegClass", "(", "index2VirtReg", "(", "i", ")", ")", "->", "getSize", "(", ")", ")", "{", "case", "4", ":", "rc32", "++", ";", "break", ";", "case", "8", ":", "rc64", "++", ";", "break", ";", "}", "}", "if", "(", "HSAILRegSlots", ">", "0", ")", "{", "RegSlots", "=", "HSAILRegSlots", ";", "}", "else", "{", "if", "(", "rc64", "<", "(", "NumSlotsTotal", "-", "RegSlots", ")", "&&", "rc32", ">", "(", "RegSlots", "*", "2", ")", ")", "{", "RegSlots", "=", "NumSlotsTotal", "-", "rc64", ";", "}", "else", "if", "(", "rc32", "<", "(", "RegSlots", "*", "2", ")", "&&", "rc64", ">", "(", "NumSlotsTotal", "-", "RegSlots", ")", ")", "{", "RegSlots", "=", "(", "rc32", "+", "1", ")", "/", "2", ";", "}", "}", "if", "(", "RegSlots", "<", "8", ")", "RegSlots", "=", "8", ";", "else", "if", "(", "RegSlots", ">", "(", "NumSlotsTotal", "-", "8", ")", ")", "RegSlots", "=", "NumSlotsTotal", "-", "8", ";", "MFI", "->", "setRegisterPartitioning", "(", "RegSlots", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nFunction: \"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\" VR count: 32 bit = \"", "<<", "rc32", "<<", "\", 64 bit = \"", "<<", "rc64", "<<", "\", register file partitioning: \"", "<<", "RegSlots", "*", "2", "<<", "\" $s + \"", "<<", "NumSlotsTotal", "-", "RegSlots", "<<", "\" $d\\n\\n\"", ")", ";", "}", "else", "{", "RegSlots", "=", "MFI", "->", "getRegisterPartitioning", "(", ")", ";", "}", "unsigned", "Reg", ";", "unsigned", "LastSReg", "=", "HSAIL", "::", "S0", "+", "HSAIL", "::", "GPR32RegClass", ".", "getNumRegs", "(", ")", "-", "1", ";", "for", "(", "Reg", "=", "HSAIL", "::", "S0", "+", "RegSlots", "*", "2", ";", "Reg", "<=", "LastSReg", ";", "++", "Reg", ")", "{", "Reserved", ".", "set", "(", "Reg", ")", ";", "}", "unsigned", "LastDReg", "=", "HSAIL", "::", "D0", "+", "HSAIL", "::", "GPR64RegClass", ".", "getNumRegs", "(", ")", "-", "1", ";", "for", "(", "Reg", "=", "HSAIL", "::", "D0", "+", "(", "NumSlotsTotal", "-", "RegSlots", ")", ";", "Reg", "<=", "LastDReg", ";", "++", "Reg", ")", "{", "Reserved", ".", "set", "(", "Reg", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "HSAIL", "HSAIL", "HSAIL", "HSAIL", "HSAIL", "HSAIL::GPR64RegClass", "2", "0", "0", "0", "0", "4", "8", "HSAIL", "0", "HSAIL", "2", "2", "1", "2", "8", "8", "8", "8", "\"\\nFunction: \"", "\" VR count: 32 bit = \"", "\", 64 bit = \"", "\", register file partitioning: \"", "2", "\" $s + \"", "\" $d\\n\\n\"", "HSAIL::S0", "HSAIL::GPR32RegClass", "1", "HSAIL::S0", "2", "HSAIL::D0", "HSAIL::GPR64RegClass", "1", "HSAIL::D0" ]

[]

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

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

[ "WebAssembly", "\"WebAssembly Argument Move\"" ]

[]

[ "<s>", "MCInst", "RISCVInstrInfo", "::", "getNop", "(", ")", "const", "{", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureStdExtC", "]", ")", "return", "MCInstBuilder", "(", "RISCV", "::", "C_NOP", ")", ";", "return", "MCInstBuilder", "(", "RISCV", "::", "ADDI", ")", ".", "addReg", "(", "RISCV", "::", "X0", ")", ".", "addReg", "(", "RISCV", "::", "X0", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

[ "Return", "the", "noop", "instruction", "to", "use", "for", "a", "noop", "." ]

[ "RISCV", "RISCV", "RISCV::FeatureStdExtC", "RISCV::C_NOP", "RISCV::ADDI", "RISCV::X0", "RISCV::X0", "0" ]

[]

[ "<s>", "const", "char", "*", "output_branch", "(", "int", "logic", ",", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ")", "{", "switch", "(", "get_attr_length", "(", "insn", ")", ")", "{", "case", "6", ":", "if", "(", "!", "TARGET_RELAX", ")", "{", "int", "label", "=", "lf", "++", ";", "rtx", "op0", "=", "operands", "[", "0", "]", ";", "if", "(", "final_sequence", "&&", "!", "INSN_ANNULLED_BRANCH_P", "(", "final_sequence", "->", "insn", "(", "0", ")", ")", "&&", "get_attr_length", "(", "final_sequence", "->", "insn", "(", "1", ")", ")", ")", "{", "asm_fprintf", "(", "asm_out_file", ",", "\"\\tb%s%ss\\t%LLF%d\\n\"", ",", "logic", "?", "\"f\"", ":", "\"t\"", ",", "ASSEMBLER_DIALECT", "?", "\"/\"", ":", "\".\"", ",", "label", ")", ";", "print_slot", "(", "final_sequence", ")", ";", "}", "else", "asm_fprintf", "(", "asm_out_file", ",", "\"\\tb%s\\t%LLF%d\\n\"", ",", "logic", "?", "\"f\"", ":", "\"t\"", ",", "label", ")", ";", "output_asm_insn", "(", "\"bra\\t%l0\"", ",", "&", "op0", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tnop\\n\"", ")", ";", "(", "*", "targetm", ".", "asm_out", ".", "internal_label", ")", "(", "asm_out_file", ",", "\"LF\"", ",", "label", ")", ";", "return", "\"\"", ";", "}", "case", "2", ":", "return", "logic", "?", "\"bt%.\\t%l0\"", ":", "\"bf%.\\t%l0\"", ";", "case", "8", ":", "if", "(", "!", "TARGET_RELAX", ")", "{", "int", "label", "=", "lf", "++", ";", "gcc_assert", "(", "!", "final_sequence", "||", "!", "(", "INSN_ANNULLED_BRANCH_P", "(", "XVECEXP", "(", "final_sequence", ",", "0", ",", "0", ")", ")", ")", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"b%s%ss\\t%LLF%d\\n\"", ",", "logic", "?", "\"f\"", ":", "\"t\"", ",", "ASSEMBLER_DIALECT", "?", "\"/\"", ":", "\".\"", ",", "label", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tnop\\n\"", ")", ";", "output_asm_insn", "(", "\"bra\\t%l0\"", ",", "operands", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tnop\\n\"", ")", ";", "(", "*", "targetm", ".", "asm_out", ".", "internal_label", ")", "(", "asm_out_file", ",", "\"LF\"", ",", "label", ")", ";", "return", "\"\"", ";", "}", "case", "4", ":", "{", "char", "buffer", "[", "10", "]", ";", "sprintf", "(", "buffer", ",", "\"b%s%ss\\t%%l0\"", ",", "logic", "?", "\"t\"", ":", "\"f\"", ",", "ASSEMBLER_DIALECT", "?", "\"/\"", ":", "\".\"", ")", ";", "output_asm_insn", "(", "buffer", ",", "&", "operands", "[", "0", "]", ")", ";", "return", "\"nop\"", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Output", "a", "conditional/unconditional", "branch", "to", "LABEL", ".", "COND", "is", "the", "string", "condition", ".", "INSN", "is", "the", "instruction", "." ]

[ "sh", "6", "0", "0", "1", "\"\\tb%s%ss\\t%LLF%d\\n\"", "\"f\"", "\"t\"", "\"/\"", "\".\"", "\"\\tb%s\\t%LLF%d\\n\"", "\"f\"", "\"t\"", "\"bra\\t%l0\"", "\"\\tnop\\n\"", "\"LF\"", "\"\"", "2", "\"bt%.\\t%l0\"", "\"bf%.\\t%l0\"", "8", "0", "0", "\"b%s%ss\\t%LLF%d\\n\"", "\"f\"", "\"t\"", "\"/\"", "\".\"", "\"\\tnop\\n\"", "\"bra\\t%l0\"", "\"\\tnop\\n\"", "\"LF\"", "\"\"", "4", "10", "\"b%s%ss\\t%%l0\"", "\"t\"", "\"f\"", "\"/\"", "\".\"", "0", "\"nop\"" ]

[]

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

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

[ "MBlaze" ]

[]

[ "<s>", "bool", "VEAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "O", ")", ";", "case", "'r'", ":", "case", "'v'", ":", "break", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "VE", "VE", "0", "1", "0", "0" ]

[]

[ "<s>", "bool", "ARMPreAllocLoadStoreOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "AssumeMisalignedLoadStores", "||", "skipFunction", "(", "*", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TD", "=", "&", "Fn", ".", "getDataLayout", "(", ")", ";", "STI", "=", "&", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "MF", "=", "&", "Fn", ";", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MFI", ":", "Fn", ")", "Modified", "|=", "RescheduleLoadStoreInstrs", "(", "&", "MFI", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

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

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

[ "MBlaze", "MBlaze" ]

[]

[ "<s>", "static", "rtx", "emit_multi_reg_push", "(", "unsigned", "long", "mask", ",", "unsigned", "long", "dwarf_regs_mask", ")", "{", "int", "num_regs", "=", "0", ";", "int", "num_dwarf_regs", "=", "0", ";", "int", "i", ",", "j", ";", "rtx", "par", ";", "rtx", "dwarf", ";", "int", "dwarf_par_index", ";", "rtx", "tmp", ",", "reg", ";", "dwarf_regs_mask", "&=", "~", "(", "1", "<<", "PC_REGNUM", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "LAST_ARM_REGNUM", ";", "i", "++", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "num_regs", "++", ";", "if", "(", "dwarf_regs_mask", "&", "(", "1", "<<", "i", ")", ")", "num_dwarf_regs", "++", ";", "}", "gcc_assert", "(", "num_regs", "&&", "num_regs", "<=", "16", ")", ";", "gcc_assert", "(", "(", "dwarf_regs_mask", "&", "~", "mask", ")", "==", "0", ")", ";", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_regs", ")", ")", ";", "dwarf", "=", "gen_rtx_SEQUENCE", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_dwarf_regs", "+", "1", ")", ")", ";", "dwarf_par_index", "=", "1", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "LAST_ARM_REGNUM", ";", "i", "++", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "gen_frame_mem", "(", "BLKmode", ",", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "4", "*", "num_regs", ")", ")", ")", ",", "gen_rtx_UNSPEC", "(", "BLKmode", ",", "gen_rtvec", "(", "1", ",", "reg", ")", ",", "UNSPEC_PUSH_MULT", ")", ")", ";", "if", "(", "dwarf_regs_mask", "&", "(", "1", "<<", "i", ")", ")", "{", "tmp", "=", "gen_rtx_SET", "(", "gen_frame_mem", "(", "SImode", ",", "stack_pointer_rtx", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "dwarf_par_index", "++", ")", "=", "tmp", ";", "}", "break", ";", "}", "}", "for", "(", "j", "=", "1", ",", "i", "++", ";", "j", "<", "num_regs", ";", "i", "++", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "j", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "reg", ")", ";", "if", "(", "dwarf_regs_mask", "&", "(", "1", "<<", "i", ")", ")", "{", "tmp", "=", "gen_rtx_SET", "(", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "4", "*", "j", ")", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "dwarf_par_index", "++", ")", "=", "tmp", ";", "}", "j", "++", ";", "}", "}", "par", "=", "emit_insn", "(", "par", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "4", "*", "num_regs", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "0", ")", "=", "tmp", ";", "add_reg_note", "(", "par", ",", "REG_FRAME_RELATED_EXPR", ",", "dwarf", ")", ";", "return", "par", ";", "}", "</s>" ]

[ "Generate", "and", "emit", "an", "insn", "that", "we", "will", "recognize", "as", "a", "push_multi", ".", "Unfortunately", ",", "since", "this", "insn", "does", "not", "reflect", "very", "well", "the", "actual", "semantics", "of", "the", "operation", ",", "we", "need", "to", "annotate", "the", "insn", "for", "the", "benefit", "of", "DWARF2", "frame", "unwind", "information", "." ]

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

[]

[ "<s>", "SDValue", "MMIXTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"unimplemented operand\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "MMIX", "MMIX", "\"unimplemented operand\"", "ISD::GlobalAddress", "ISD::SELECT" ]

[]

[ "<s>", "bool", "MCS51ExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Modified", "=", "false", ";", "const", "MCS51Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "MCS51Subtarget", ">", "(", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "MF", ".", "getProperties", "(", ")", ".", "set", "(", "MachineFunctionProperties", "::", "Property", "::", "TracksLiveness", ")", ";", "for", "(", "Block", "&", "MBB", ":", "MF", ")", "{", "bool", "ContinueExpanding", "=", "true", ";", "unsigned", "ExpandCount", "=", "0", ";", "do", "{", "assert", "(", "ExpandCount", "<", "10", "&&", "\"pseudo expand limit reached\"", ")", ";", "bool", "BlockModified", "=", "expandMBB", "(", "MBB", ")", ";", "Modified", "|=", "BlockModified", ";", "ExpandCount", "++", ";", "ContinueExpanding", "=", "BlockModified", ";", "}", "while", "(", "ContinueExpanding", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51", "MCS51", "MCS51", "0", "10", "\"pseudo expand limit reached\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getPointerRegClass", "(", "unsigned", "Kind", ")", "const", "{", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected Kind in getPointerRegClass!\"", ")", ";", "case", "0", ":", "if", "(", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ")", "return", "&", "X86", "::", "GR64RegClass", ";", "return", "&", "X86", "::", "GR32RegClass", ";", "case", "1", ":", "if", "(", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOSPRegClass", ";", "return", "&", "X86", "::", "GR32_NOSPRegClass", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "\"Unexpected Kind in getPointerRegClass!\"", "0", "X86", "X86::GR64RegClass", "X86::GR32RegClass", "1", "X86", "X86::GR64_NOSPRegClass", "X86::GR32_NOSPRegClass" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "MachineFunction", "&", "MF", ",", "unsigned", "Intrinsic", ")", "const", "{", "switch", "(", "Intrinsic", ")", "{", "case", "Intrinsic", "::", "ppc_altivec_lvx", ":", "case", "Intrinsic", "::", "ppc_altivec_lvxl", ":", "case", "Intrinsic", "::", "ppc_altivec_lvebx", ":", "case", "Intrinsic", "::", "ppc_altivec_lvehx", ":", "case", "Intrinsic", "::", "ppc_altivec_lvewx", ":", "case", "Intrinsic", "::", "ppc_vsx_lxvd2x", ":", "case", "Intrinsic", "::", "ppc_vsx_lxvw4x", ":", "case", "Intrinsic", "::", "ppc_vsx_lxvd2x_be", ":", "case", "Intrinsic", "::", "ppc_vsx_lxvw4x_be", ":", "case", "Intrinsic", "::", "ppc_vsx_lxvl", ":", "case", "Intrinsic", "::", "ppc_vsx_lxvll", ":", "{", "EVT", "VT", ";", "switch", "(", "Intrinsic", ")", "{", "case", "Intrinsic", "::", "ppc_altivec_lvebx", ":", "VT", "=", "MVT", "::", "i8", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_lvehx", ":", "VT", "=", "MVT", "::", "i16", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_lvewx", ":", "VT", "=", "MVT", "::", "i32", ";", "break", ";", "case", "Intrinsic", "::", "ppc_vsx_lxvd2x", ":", "case", "Intrinsic", "::", "ppc_vsx_lxvd2x_be", ":", "VT", "=", "MVT", "::", "v2f64", ";", "break", ";", "default", ":", "VT", "=", "MVT", "::", "v4i32", ";", "break", ";", "}", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "VT", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "-", "VT", ".", "getStoreSize", "(", ")", "+", "1", ";", "Info", ".", "size", "=", "2", "*", "VT", ".", "getStoreSize", "(", ")", "-", "1", ";", "Info", ".", "align", "=", "Align", "(", "1", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "ppc_altivec_stvx", ":", "case", "Intrinsic", "::", "ppc_altivec_stvxl", ":", "case", "Intrinsic", "::", "ppc_altivec_stvebx", ":", "case", "Intrinsic", "::", "ppc_altivec_stvehx", ":", "case", "Intrinsic", "::", "ppc_altivec_stvewx", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvd2x", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvw4x", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvd2x_be", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvw4x_be", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvl", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvll", ":", "{", "EVT", "VT", ";", "switch", "(", "Intrinsic", ")", "{", "case", "Intrinsic", "::", "ppc_altivec_stvebx", ":", "VT", "=", "MVT", "::", "i8", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_stvehx", ":", "VT", "=", "MVT", "::", "i16", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_stvewx", ":", "VT", "=", "MVT", "::", "i32", ";", "break", ";", "case", "Intrinsic", "::", "ppc_vsx_stxvd2x", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvd2x_be", ":", "VT", "=", "MVT", "::", "v2f64", ";", "break", ";", "default", ":", "VT", "=", "MVT", "::", "v4i32", ";", "break", ";", "}", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_VOID", ";", "Info", ".", "memVT", "=", "VT", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "1", ")", ";", "Info", ".", "offset", "=", "-", "VT", ".", "getStoreSize", "(", ")", "+", "1", ";", "Info", ".", "size", "=", "2", "*", "VT", ".", "getStoreSize", "(", ")", "-", "1", ";", "Info", ".", "align", "=", "Align", "(", "1", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOStore", ";", "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", ")", "." ]

[ "PowerPC", "PPC", "Intrinsic::ppc_altivec_lvx", "Intrinsic::ppc_altivec_lvxl", "Intrinsic::ppc_altivec_lvebx", "Intrinsic::ppc_altivec_lvehx", "Intrinsic::ppc_altivec_lvewx", "Intrinsic::ppc_vsx_lxvd2x", "Intrinsic::ppc_vsx_lxvw4x", "Intrinsic::ppc_vsx_lxvd2x_be", "Intrinsic::ppc_vsx_lxvw4x_be", "Intrinsic::ppc_vsx_lxvl", "Intrinsic::ppc_vsx_lxvll", "Intrinsic::ppc_altivec_lvebx", "MVT::i8", "Intrinsic::ppc_altivec_lvehx", "MVT::i16", "Intrinsic::ppc_altivec_lvewx", "MVT::i32", "Intrinsic::ppc_vsx_lxvd2x", "Intrinsic::ppc_vsx_lxvd2x_be", "MVT::v2f64", "MVT::v4i32", "ISD::INTRINSIC_W_CHAIN", "0", "1", "2", "1", "1", "Intrinsic::ppc_altivec_stvx", "Intrinsic::ppc_altivec_stvxl", "Intrinsic::ppc_altivec_stvebx", "Intrinsic::ppc_altivec_stvehx", "Intrinsic::ppc_altivec_stvewx", "Intrinsic::ppc_vsx_stxvd2x", "Intrinsic::ppc_vsx_stxvw4x", "Intrinsic::ppc_vsx_stxvd2x_be", "Intrinsic::ppc_vsx_stxvw4x_be", "Intrinsic::ppc_vsx_stxvl", "Intrinsic::ppc_vsx_stxvll", "Intrinsic::ppc_altivec_stvebx", "MVT::i8", "Intrinsic::ppc_altivec_stvehx", "MVT::i16", "Intrinsic::ppc_altivec_stvewx", "MVT::i32", "Intrinsic::ppc_vsx_stxvd2x", "Intrinsic::ppc_vsx_stxvd2x_be", "MVT::v2f64", "MVT::v4i32", "ISD::INTRINSIC_VOID", "1", "1", "2", "1", "1" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AS", ")", "{", "case", "AMDGPUAS", "::", "GLOBAL_ADDRESS", ":", "case", "AMDGPUAS", "::", "CONSTANT_ADDRESS", ":", "case", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ":", "case", "AMDGPUAS", "::", "UNKNOWN_ADDRESS_SPACE", ":", "{", "if", "(", "!", "isUInt", "<", "12", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "return", "true", ";", "case", "1", ":", "return", "true", ";", "case", "2", ":", "if", "(", "AM", ".", "HasBaseReg", ")", "{", "return", "false", ";", "}", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "case", "AMDGPUAS", "::", "LOCAL_ADDRESS", ":", "case", "AMDGPUAS", "::", "REGION_ADDRESS", ":", "{", "if", "(", "!", "isUInt", "<", "16", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "Scale", "==", "0", ")", "return", "true", ";", "if", "(", "AM", ".", "Scale", "==", "1", "&&", "AM", ".", "HasBaseReg", ")", "return", "true", ";", "return", "false", ";", "}", "case", "AMDGPUAS", "::", "FLAT_ADDRESS", ":", "{", "return", "AM", ".", "BaseOffs", "==", "0", "&&", "(", "AM", ".", "Scale", "==", "0", "||", "AM", ".", "Scale", "==", "1", ")", ";", "}", "default", ":", "llvm_unreachable", "(", "\"unhandled address space\"", ")", ";", "}", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "R600", "SI", "AMDGPUAS::GLOBAL_ADDRESS", "AMDGPUAS::CONSTANT_ADDRESS", "AMDGPUAS::PRIVATE_ADDRESS", "AMDGPUAS::UNKNOWN_ADDRESS_SPACE", "12", "0", "1", "2", "AMDGPUAS::LOCAL_ADDRESS", "AMDGPUAS::REGION_ADDRESS", "16", "0", "1", "AMDGPUAS::FLAT_ADDRESS", "0", "0", "1", "\"unhandled address space\"" ]

[]

[ "<s>", "static", "parallel", "*", "nvptx_find_par", "(", "bb_insn_map_t", "*", "map", ",", "parallel", "*", "par", ",", "basic_block", "block", ")", "{", "if", "(", "block", "->", "flags", "&", "BB_VISITED", ")", "return", "par", ";", "block", "->", "flags", "|=", "BB_VISITED", ";", "if", "(", "rtx_insn", "*", "*", "endp", "=", "map", "->", "get", "(", "block", ")", ")", "{", "rtx_insn", "*", "end", "=", "*", "endp", ";", "switch", "(", "recog_memoized", "(", "end", ")", ")", "{", "case", "CODE_FOR_return", ":", "return", "par", ";", "case", "CODE_FOR_nvptx_forked", ":", "{", "unsigned", "mask", "=", "UINTVAL", "(", "XVECEXP", "(", "PATTERN", "(", "end", ")", ",", "0", ",", "0", ")", ")", ";", "gcc_assert", "(", "mask", ")", ";", "par", "=", "new", "parallel", "(", "par", ",", "mask", ")", ";", "par", "->", "forked_block", "=", "block", ";", "par", "->", "forked_insn", "=", "end", ";", "if", "(", "!", "(", "mask", "&", "GOMP_DIM_MASK", "(", "GOMP_DIM_MAX", ")", ")", "&&", "(", "mask", "&", "GOMP_DIM_MASK", "(", "GOMP_DIM_WORKER", ")", ")", ")", "par", "->", "fork_insn", "=", "nvptx_discover_pre", "(", "block", ",", "CODE_FOR_nvptx_fork", ")", ";", "}", "break", ";", "case", "CODE_FOR_nvptx_join", ":", "{", "unsigned", "mask", "=", "UINTVAL", "(", "XVECEXP", "(", "PATTERN", "(", "end", ")", ",", "0", ",", "0", ")", ")", ";", "gcc_assert", "(", "par", "->", "mask", "==", "mask", ")", ";", "par", "->", "join_block", "=", "block", ";", "par", "->", "join_insn", "=", "end", ";", "if", "(", "!", "(", "mask", "&", "GOMP_DIM_MASK", "(", "GOMP_DIM_MAX", ")", ")", "&&", "(", "mask", "&", "GOMP_DIM_MASK", "(", "GOMP_DIM_WORKER", ")", ")", ")", "par", "->", "joining_insn", "=", "nvptx_discover_pre", "(", "block", ",", "CODE_FOR_nvptx_joining", ")", ";", "par", "=", "par", "->", "parent", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "par", ")", "par", "->", "blocks", ".", "safe_push", "(", "block", ")", ";", "else", "par", "=", "new", "parallel", "(", "0", ",", "0", ")", ";", "edge", "e", ";", "edge_iterator", "ei", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "block", "->", "succs", ")", "nvptx_find_par", "(", "map", ",", "par", ",", "e", "->", "dest", ")", ";", "return", "par", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "TargetTransformInfo", "::", "PopcntSupportKind", "X86TTIImpl", "::", "getPopcntSupport", "(", "unsigned", "TyWidth", ")", "{", "assert", "(", "isPowerOf2_32", "(", "TyWidth", ")", "&&", "\"Ty width must be power of 2\"", ")", ";", "return", "ST", "->", "hasPOPCNT", "(", ")", "?", "TTI", "::", "PSK_FastHardware", ":", "TTI", "::", "PSK_Software", ";", "}", "</s>" ]

[ "Return", "hardware", "support", "for", "population", "count", "." ]

[ "X86", "X86", "\"Ty width must be power of 2\"" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "HexagonRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "MCPhysReg", "CalleeSavedRegsV3", "[", "]", "=", "{", "Hexagon", "::", "R16", ",", "Hexagon", "::", "R17", ",", "Hexagon", "::", "R18", ",", "Hexagon", "::", "R19", ",", "Hexagon", "::", "R20", ",", "Hexagon", "::", "R21", ",", "Hexagon", "::", "R22", ",", "Hexagon", "::", "R23", ",", "Hexagon", "::", "R24", ",", "Hexagon", "::", "R25", ",", "Hexagon", "::", "R26", ",", "Hexagon", "::", "R27", ",", "0", "}", ";", "static", "const", "MCPhysReg", "CalleeSavedRegsV3EHReturn", "[", "]", "=", "{", "Hexagon", "::", "R0", ",", "Hexagon", "::", "R1", ",", "Hexagon", "::", "R2", ",", "Hexagon", "::", "R3", ",", "Hexagon", "::", "R16", ",", "Hexagon", "::", "R17", ",", "Hexagon", "::", "R18", ",", "Hexagon", "::", "R19", ",", "Hexagon", "::", "R20", ",", "Hexagon", "::", "R21", ",", "Hexagon", "::", "R22", ",", "Hexagon", "::", "R23", ",", "Hexagon", "::", "R24", ",", "Hexagon", "::", "R25", ",", "Hexagon", "::", "R26", ",", "Hexagon", "::", "R27", ",", "0", "}", ";", "bool", "HasEHReturn", "=", "MF", "->", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", "->", "hasEHReturn", "(", ")", ";", "return", "HasEHReturn", "?", "CalleeSavedRegsV3EHReturn", ":", "CalleeSavedRegsV3", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::R16", "Hexagon::R17", "Hexagon::R18", "Hexagon::R19", "Hexagon::R20", "Hexagon::R21", "Hexagon::R22", "Hexagon::R23", "Hexagon::R24", "Hexagon::R25", "Hexagon::R26", "Hexagon::R27", "0", "Hexagon::R0", "Hexagon::R1", "Hexagon::R2", "Hexagon::R3", "Hexagon::R16", "Hexagon::R17", "Hexagon::R18", "Hexagon::R19", "Hexagon::R20", "Hexagon::R21", "Hexagon::R22", "Hexagon::R23", "Hexagon::R24", "Hexagon::R25", "Hexagon::R26", "Hexagon::R27", "0", "Hexagon" ]

[]

[ "<s>", "bool", "SystemZTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "return", "Imm", ".", "isZero", "(", ")", "||", "Imm", ".", "isNegZero", "(", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "void", "XCoreTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "DataSection", "=", "MCSectionXCore", "::", "Create", "(", "\".dp.data\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "MCSectionELF", "::", "SHF_ALLOC", "|", "MCSectionELF", "::", "SHF_WRITE", "|", "MCSectionXCore", "::", "SHF_DP_SECTION", ",", "SectionKind", "::", "getDataRel", "(", ")", ",", "false", ",", "getContext", "(", ")", ")", ";", "BSSSection", "=", "MCSectionXCore", "::", "Create", "(", "\".dp.bss\"", ",", "MCSectionELF", "::", "SHT_NOBITS", ",", "MCSectionELF", "::", "SHF_ALLOC", "|", "MCSectionELF", "::", "SHF_WRITE", "|", "MCSectionXCore", "::", "SHF_DP_SECTION", ",", "SectionKind", "::", "getBSS", "(", ")", ",", "false", ",", "getContext", "(", ")", ")", ";", "MergeableConst4Section", "=", "MCSectionXCore", "::", "Create", "(", "\".cp.rodata.cst4\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "MCSectionELF", "::", "SHF_ALLOC", "|", "MCSectionELF", "::", "SHF_MERGE", "|", "MCSectionXCore", "::", "SHF_CP_SECTION", ",", "SectionKind", "::", "getMergeableConst4", "(", ")", ",", "false", ",", "getContext", "(", ")", ")", ";", "MergeableConst8Section", "=", "MCSectionXCore", "::", "Create", "(", "\".cp.rodata.cst8\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "MCSectionELF", "::", "SHF_ALLOC", "|", "MCSectionELF", "::", "SHF_MERGE", "|", "MCSectionXCore", "::", "SHF_CP_SECTION", ",", "SectionKind", "::", "getMergeableConst8", "(", ")", ",", "false", ",", "getContext", "(", ")", ")", ";", "MergeableConst16Section", "=", "MCSectionXCore", "::", "Create", "(", "\".cp.rodata.cst16\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "MCSectionELF", "::", "SHF_ALLOC", "|", "MCSectionELF", "::", "SHF_MERGE", "|", "MCSectionXCore", "::", "SHF_CP_SECTION", ",", "SectionKind", "::", "getMergeableConst16", "(", ")", ",", "false", ",", "getContext", "(", ")", ")", ";", "TLSDataSection", "=", "DataSection", ";", "TLSBSSSection", "=", "BSSSection", ";", "if", "(", "TM", ".", "getSubtarget", "<", "XCoreSubtarget", ">", "(", ")", ".", "isXS1A", "(", ")", ")", "ReadOnlySection", "=", "MCSectionXCore", "::", "Create", "(", "\".dp.rodata\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "MCSectionELF", "::", "SHF_ALLOC", "|", "MCSectionELF", "::", "SHF_WRITE", "|", "MCSectionXCore", "::", "SHF_DP_SECTION", ",", "SectionKind", "::", "getDataRel", "(", ")", ",", "false", ",", "getContext", "(", ")", ")", ";", "else", "ReadOnlySection", "=", "MCSectionXCore", "::", "Create", "(", "\".cp.rodata\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "MCSectionELF", "::", "SHF_ALLOC", "|", "MCSectionXCore", "::", "SHF_CP_SECTION", ",", "SectionKind", "::", "getReadOnlyWithRel", "(", ")", ",", "false", ",", "getContext", "(", ")", ")", ";", "DataRelSection", "=", "DataRelLocalSection", "=", "DataSection", ";", "DataRelROSection", "=", "DataRelROLocalSection", "=", "ReadOnlySection", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "\".dp.data\"", "XCore", "XCore", "\".dp.bss\"", "XCore", "XCore", "\".cp.rodata.cst4\"", "XCore", "XCore", "\".cp.rodata.cst8\"", "XCore", "XCore", "\".cp.rodata.cst16\"", "XCore", "XCore", "XCore", "\".dp.rodata\"", "XCore", "XCore", "\".cp.rodata\"", "XCore" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isInlineConstant", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "isInlineConstant", "(", "APInt", "(", "32", ",", "MO", ".", "getImm", "(", ")", ",", "true", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "returns", "true", "if", "the", "operand", "OpIdx", "in", "MI", "is", "a", "valid", "inline", "immediate", "." ]

[ "R600", "SI", "32" ]

[]

[ "<s>", "XCoreSubtarget", "::", "XCoreSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ")", ":", "IsXS1A", "(", "false", ")", ",", "IsXS1B", "(", "false", ")", "{", "std", "::", "string", "CPU", "=", "\"xs1a-generic\"", ";", "ParseSubtargetFeatures", "(", "FS", ",", "CPU", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "\"xs1a-generic\"" ]

[]

[ "<s>", "static", "rtx", "gen_tlsmoff", "(", "rtx", "addr", ",", "rtx", "reg", ")", "{", "rtx", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "if", "(", "TARGET_BIG_TLS", ")", "{", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_tlsoff_hilo", "(", "dest", ",", "addr", ",", "GEN_INT", "(", "R_FRV_TLSMOFFHI", ")", ")", ")", ";", "dest", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "dest", ",", "reg", ")", ";", "}", "else", "{", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_symGOTOFF2reg_i", "(", "dest", ",", "addr", ",", "reg", ",", "GEN_INT", "(", "R_FRV_TLSMOFF12", ")", ")", ")", ";", "}", "return", "dest", ";", "}", "</s>" ]

[ "Emit", "a", "TLSMOFF", "or", "TLSMOFF12", "offset", ",", "depending", "on", "-mTLS", ".", "Returns", "the", "destination", "address", "." ]

[ "frv" ]

[]

[ "<s>", "bool", "isMachineVerifierClean", "(", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "is", "expected", "to", "pass", "all", "machine", "verifier", "checks", "." ]

[ "SystemZ" ]

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "getAddr", "(", "NodeTy", "*", "N", ",", "SelectionDAG", "&", "DAG", ",", "bool", "IsLocal", ")", "const", "{", "SDLoc", "DL", "(", "N", ")", ";", "EVT", "Ty", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "if", "(", "isPositionIndependent", "(", ")", ")", "{", "SDValue", "Addr", "=", "getTargetNode", "(", "N", ",", "DL", ",", "Ty", ",", "DAG", ",", "0", ")", ";", "if", "(", "IsLocal", ")", "return", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "RISCV", "::", "PseudoLLA", ",", "DL", ",", "Ty", ",", "Addr", ")", ",", "0", ")", ";", "return", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "RISCV", "::", "PseudoLA", ",", "DL", ",", "Ty", ",", "Addr", ")", ",", "0", ")", ";", "}", "switch", "(", "getTargetMachine", "(", ")", ".", "getCodeModel", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"Unsupported code model for lowering\"", ")", ";", "case", "CodeModel", "::", "Small", ":", "{", "SDValue", "AddrHi", "=", "getTargetNode", "(", "N", ",", "DL", ",", "Ty", ",", "DAG", ",", "RISCVII", "::", "MO_HI", ")", ";", "SDValue", "AddrLo", "=", "getTargetNode", "(", "N", ",", "DL", ",", "Ty", ",", "DAG", ",", "RISCVII", "::", "MO_LO", ")", ";", "SDValue", "MNHi", "=", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "RISCV", "::", "LUI", ",", "DL", ",", "Ty", ",", "AddrHi", ")", ",", "0", ")", ";", "return", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "RISCV", "::", "ADDI", ",", "DL", ",", "Ty", ",", "MNHi", ",", "AddrLo", ")", ",", "0", ")", ";", "}", "case", "CodeModel", "::", "Medium", ":", "{", "SDValue", "Addr", "=", "getTargetNode", "(", "N", ",", "DL", ",", "Ty", ",", "DAG", ",", "0", ")", ";", "return", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "RISCV", "::", "PseudoLLA", ",", "DL", ",", "Ty", ",", "Addr", ")", ",", "0", ")", ";", "}", "}", "}", "</s>" ]

[ "Return", "the", "address", "accessed", "by", "this", "recipe", "." ]

[ "RISCV", "RISCV", "0", "RISCV::PseudoLLA", "0", "RISCV::PseudoLA", "0", "\"Unsupported code model for lowering\"", "RISCVII::MO_HI", "RISCVII::MO_LO", "RISCV::LUI", "0", "RISCV::ADDI", "0", "0", "RISCV::PseudoLLA", "0" ]

[]

[ "<s>", "bool", "isValidState", "(", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "See", "AbstractState", ":", ":isValidState", "(", "...", ")" ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "VZeroUpperInserter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasAVX", "(", ")", "||", "ST", ".", "hasFastPartialYMMorZMMWrite", "(", ")", ")", "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", ";", "const", "TargetRegisterClass", "*", "RCs", "[", "2", "]", "=", "{", "&", "X86", "::", "VR256RegClass", ",", "&", "X86", "::", "VR512RegClass", "}", ";", "for", "(", "auto", "*", "RC", ":", "RCs", ")", "{", "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", ")", "{", "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", "2", "X86::VR256RegClass", "X86::VR512RegClass", "\"X86VZeroUpper state should be clear\"", "\"MBB #\"", "\" was Pass-through, is now Dirty-out.\\n\"" ]

[]

[ "<s>", "bool", "AMDGPUPromoteAllocaToVector", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "if", "(", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ")", "{", "return", "promoteAllocasToVector", "(", "F", ",", "TPC", "->", "getTM", "<", "TargetMachine", ">", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "rtx", "sparc_delegitimize_address", "(", "rtx", "x", ")", "{", "x", "=", "delegitimize_mem_from_attrs", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "XEXP", "(", "x", ",", "1", ")", ",", "1", ")", ")", "{", "case", "UNSPEC_MOVE_PIC", ":", "case", "UNSPEC_TLSLE", ":", "x", "=", "XVECEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "MINUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PIC_OFFSET_TABLE_REGNUM", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "LO_SUM", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "1", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "1", ")", ",", "1", ")", "==", "UNSPEC_MOVE_PIC_LABEL", ")", "{", "x", "=", "XVECEXP", "(", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "1", ")", ",", "0", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "Delegitimize", "an", "address", "that", "was", "legitimized", "by", "the", "above", "function", "." ]

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

[]

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

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

[ "X86", "X86" ]

[]

[ "<s>", "static", "void", "pro_epilogue_adjust_stack", "(", "rtx", "dest", ",", "rtx", "src", ",", "rtx", "offset", ",", "int", "style", ",", "bool", "set_cfa", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "rtx", "insn", ";", "bool", "add_frame_related_expr", "=", "false", ";", "if", "(", "Pmode", "==", "SImode", ")", "insn", "=", "gen_pro_epilogue_adjust_stack_si_add", "(", "dest", ",", "src", ",", "offset", ")", ";", "else", "if", "(", "x86_64_immediate_operand", "(", "offset", ",", "DImode", ")", ")", "insn", "=", "gen_pro_epilogue_adjust_stack_di_add", "(", "dest", ",", "src", ",", "offset", ")", ";", "else", "{", "rtx", "tmp", ";", "if", "(", "style", ")", "tmp", "=", "gen_rtx_REG", "(", "DImode", ",", "R11_REG", ")", ";", "else", "{", "gcc_assert", "(", "src", "!=", "hard_frame_pointer_rtx", "&&", "dest", "!=", "hard_frame_pointer_rtx", ")", ";", "tmp", "=", "hard_frame_pointer_rtx", ";", "}", "insn", "=", "emit_insn", "(", "gen_rtx_SET", "(", "tmp", ",", "offset", ")", ")", ";", "if", "(", "style", "<", "0", ")", "add_frame_related_expr", "=", "true", ";", "insn", "=", "gen_pro_epilogue_adjust_stack_di_add", "(", "dest", ",", "src", ",", "tmp", ")", ";", "}", "insn", "=", "emit_insn", "(", "insn", ")", ";", "if", "(", "style", ">=", "0", ")", "ix86_add_queued_cfa_restore_notes", "(", "insn", ")", ";", "if", "(", "set_cfa", ")", "{", "rtx", "r", ";", "gcc_assert", "(", "m", "->", "fs", ".", "cfa_reg", "==", "src", ")", ";", "m", "->", "fs", ".", "cfa_offset", "+=", "INTVAL", "(", "offset", ")", ";", "m", "->", "fs", ".", "cfa_reg", "=", "dest", ";", "r", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "src", ",", "offset", ")", ";", "r", "=", "gen_rtx_SET", "(", "dest", ",", "r", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "r", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "else", "if", "(", "style", "<", "0", ")", "{", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "if", "(", "add_frame_related_expr", ")", "{", "rtx", "r", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "src", ",", "offset", ")", ";", "r", "=", "gen_rtx_SET", "(", "dest", ",", "r", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "r", ")", ";", "}", "}", "if", "(", "dest", "==", "stack_pointer_rtx", ")", "{", "HOST_WIDE_INT", "ooffset", "=", "m", "->", "fs", ".", "sp_offset", ";", "bool", "valid", "=", "m", "->", "fs", ".", "sp_valid", ";", "if", "(", "src", "==", "hard_frame_pointer_rtx", ")", "{", "valid", "=", "m", "->", "fs", ".", "fp_valid", ";", "ooffset", "=", "m", "->", "fs", ".", "fp_offset", ";", "}", "else", "if", "(", "src", "==", "crtl", "->", "drap_reg", ")", "{", "valid", "=", "m", "->", "fs", ".", "drap_valid", ";", "ooffset", "=", "0", ";", "}", "else", "{", "gcc_checking_assert", "(", "src", "==", "stack_pointer_rtx", "||", "offset", "==", "const0_rtx", ")", ";", "}", "m", "->", "fs", ".", "sp_offset", "=", "ooffset", "-", "INTVAL", "(", "offset", ")", ";", "m", "->", "fs", ".", "sp_valid", "=", "valid", ";", "}", "}", "</s>" ]

[ "Expand", "prologue", "or", "epilogue", "stack", "adjustment", ".", "The", "pattern", "exist", "to", "put", "a", "dependency", "on", "all", "ebp-based", "memory", "accesses", ".", "STYLE", "should", "be", "negative", "if", "instructions", "should", "be", "marked", "as", "frame", "related", ",", "zero", "if", "%", "r11", "register", "is", "live", "and", "can", "not", "be", "freely", "used", "and", "positive", "otherwise", "." ]

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

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "MMIX" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "isFrameStoreOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "if", "(", "MI", "->", "getOperand", "(", "X86", "::", "AddrNumOperands", ")", ".", "getSubReg", "(", ")", "==", "0", "&&", "isFrameOperand", "(", "MI", ",", "0", ",", "FrameIndex", ")", ")", "return", "MI", "->", "getOperand", "(", "X86", "::", "AddrNumOperands", ")", ".", "getReg", "(", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::AddrNumOperands", "0", "0", "X86::AddrNumOperands", "0" ]

[]

[ "<s>", "void", "rl78_expand_compare", "(", "rtx", "*", "operands", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "MEM", ")", "operands", "[", "2", "]", "=", "copy_to_mode_reg", "(", "GET_MODE", "(", "operands", "[", "2", "]", ")", ",", "operands", "[", "2", "]", ")", ";", "}", "</s>" ]

[ "Expander", "for", "cbranchqi4", "and", "cbranchhi4", ".", "RL78", "is", "missing", "some", "of", "the", "``", "normal", "''", "compares", ",", "specifically", ",", "it", "only", "has", "unsigned", "compares", ",", "so", "we", "must", "synthesize", "the", "missing", "ones", "." ]

[ "rl78", "2", "2", "2", "2" ]

[]

[ "<s>", "bool", "FixupLEAPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "X86Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "IsSlowLEA", "=", "ST", ".", "slowLEA", "(", ")", ";", "bool", "IsSlow3OpsLEA", "=", "ST", ".", "slow3OpsLEA", "(", ")", ";", "bool", "LEAUsesAG", "=", "ST", ".", "LEAusesAG", "(", ")", ";", "bool", "OptIncDec", "=", "!", "ST", ".", "slowIncDec", "(", ")", "||", "MF", ".", "getFunction", "(", ")", ".", "hasOptSize", "(", ")", ";", "bool", "UseLEAForSP", "=", "ST", ".", "useLeaForSP", "(", ")", ";", "TSM", ".", "init", "(", "&", "ST", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "auto", "*", "PSI", "=", "&", "getAnalysis", "<", "ProfileSummaryInfoWrapperPass", ">", "(", ")", ".", "getPSI", "(", ")", ";", "auto", "*", "MBFI", "=", "(", "PSI", "&&", "PSI", "->", "hasProfileSummary", "(", ")", ")", "?", "&", "getAnalysis", "<", "LazyMachineBlockFrequencyInfoPass", ">", "(", ")", ".", "getBFI", "(", ")", ":", "nullptr", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Start X86FixupLEAs\\n\"", ";", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "bool", "OptIncDecPerBB", "=", "OptIncDec", "||", "llvm", "::", "shouldOptimizeForSize", "(", "&", "MBB", ",", "PSI", ",", "MBFI", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "++", "I", ")", "{", "if", "(", "!", "isLEA", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "continue", ";", "if", "(", "optTwoAddrLEA", "(", "I", ",", "MBB", ",", "OptIncDecPerBB", ",", "UseLEAForSP", ")", ")", "continue", ";", "if", "(", "IsSlowLEA", ")", "processInstructionForSlowLEA", "(", "I", ",", "MBB", ")", ";", "else", "if", "(", "IsSlow3OpsLEA", ")", "processInstrForSlow3OpLEA", "(", "I", ",", "MBB", ",", "OptIncDecPerBB", ")", ";", "}", "if", "(", "LEAUsesAG", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "++", "I", ")", "processInstruction", "(", "I", ",", "MBB", ")", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"End X86FixupLEAs\\n\"", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"Start X86FixupLEAs\\n\"", "\"End X86FixupLEAs\\n\"" ]

[]

[ "<s>", "static", "void", "rs6000_invalid_builtin", "(", "enum", "rs6000_builtins", "fncode", ")", "{", "size_t", "uns_fncode", "=", "(", "size_t", ")", "fncode", ";", "const", "char", "*", "name", "=", "rs6000_builtin_info", "[", "uns_fncode", "]", ".", "name", ";", "HOST_WIDE_INT", "fnmask", "=", "rs6000_builtin_info", "[", "uns_fncode", "]", ".", "mask", ";", "gcc_assert", "(", "name", "!=", "NULL", ")", ";", "if", "(", "(", "fnmask", "&", "RS6000_BTM_CELL", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s is only valid for the cell processor\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_VSX", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s requires the -mvsx option\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_HTM", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s requires the -mhtm option\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_ALTIVEC", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s requires the -maltivec option\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_PAIRED", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s requires the -mpaired option\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_SPE", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s requires the -mspe option\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "(", "RS6000_BTM_DFP", "|", "RS6000_BTM_P8_VECTOR", ")", ")", "==", "(", "RS6000_BTM_DFP", "|", "RS6000_BTM_P8_VECTOR", ")", ")", "error", "(", "\"Builtin function %s requires the -mhard-dfp and\"", "\" -mpower8-vector options\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_DFP", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s requires the -mhard-dfp option\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_P8_VECTOR", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s requires the -mpower8-vector option\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "(", "RS6000_BTM_HARD_FLOAT", "|", "RS6000_BTM_LDBL128", ")", ")", "==", "(", "RS6000_BTM_HARD_FLOAT", "|", "RS6000_BTM_LDBL128", ")", ")", "error", "(", "\"Builtin function %s requires the -mhard-float and\"", "\" -mlong-double-128 options\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_HARD_FLOAT", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s requires the -mhard-float option\"", ",", "name", ")", ";", "else", "error", "(", "\"Builtin function %s is not supported with the current options\"", ",", "name", ")", ";", "}", "</s>" ]

[ "Raise", "an", "error", "message", "for", "a", "builtin", "function", "that", "is", "called", "without", "the", "appropriate", "target", "options", "being", "set", "." ]

[ "rs6000", "0", "\"Builtin function %s is only valid for the cell processor\"", "0", "\"Builtin function %s requires the -mvsx option\"", "0", "\"Builtin function %s requires the -mhtm option\"", "0", "\"Builtin function %s requires the -maltivec option\"", "0", "\"Builtin function %s requires the -mpaired option\"", "0", "\"Builtin function %s requires the -mspe option\"", "\"Builtin function %s requires the -mhard-dfp and\"", "\" -mpower8-vector options\"", "0", "\"Builtin function %s requires the -mhard-dfp option\"", "0", "\"Builtin function %s requires the -mpower8-vector option\"", "\"Builtin function %s requires the -mhard-float and\"", "\" -mlong-double-128 options\"", "0", "\"Builtin function %s requires the -mhard-float option\"", "\"Builtin function %s is not supported with the current options\"" ]

[]

[ "<s>", "static", "rtx", "arm_expand_binop_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "arglist", ",", "rtx", "target", ")", "{", "rtx", "pat", ";", "tree", "arg0", "=", "TREE_VALUE", "(", "arglist", ")", ";", "tree", "arg1", "=", "TREE_VALUE", "(", "TREE_CHAIN", "(", "arglist", ")", ")", ";", "rtx", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "0", ")", ";", "rtx", "op1", "=", "expand_expr", "(", "arg1", ",", "NULL_RTX", ",", "VOIDmode", ",", "0", ")", ";", "enum", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "enum", "machine_mode", "mode0", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "mode", ";", "enum", "machine_mode", "mode1", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "2", "]", ".", "mode", ";", "if", "(", "VECTOR_MODE_P", "(", "mode0", ")", ")", "op0", "=", "safe_vector_operand", "(", "op0", ",", "mode0", ")", ";", "if", "(", "VECTOR_MODE_P", "(", "mode1", ")", ")", "op1", "=", "safe_vector_operand", "(", "op1", ",", "mode1", ")", ";", "if", "(", "!", "target", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", ")", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "op0", ")", "==", "mode0", "&&", "GET_MODE", "(", "op1", ")", "==", "mode1", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "predicate", ")", "(", "op0", ",", "mode0", ")", ")", "op0", "=", "copy_to_mode_reg", "(", "mode0", ",", "op0", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "2", "]", ".", "predicate", ")", "(", "op1", ",", "mode1", ")", ")", "op1", "=", "copy_to_mode_reg", "(", "mode1", ",", "op1", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ",", "op1", ")", ";", "if", "(", "!", "pat", ")", "return", "0", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Subroutine", "of", "arm_expand_builtin", "to", "take", "care", "of", "binop", "insns", "." ]

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

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "getNumLDMAddresses", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Size", "=", "0", ";", "for", "(", "MachineInstr", "::", "mmo_iterator", "I", "=", "MI", ".", "memoperands_begin", "(", ")", ",", "E", "=", "MI", ".", "memoperands_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Size", "+=", "(", "*", "I", ")", "->", "getSize", "(", ")", ";", "}", "return", "Size", "/", "4", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "addresses", "by", "LDM", "or", "VLDM", "or", "zero", "for", "unknown", "." ]

[ "ARM", "ARM", "0", "4" ]

[]

[ "<s>", "DecodeStatus", "XtensaDisassembler", "::", "getInstruction", "(", "MCInst", "&", "instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "vStream", ",", "raw_ostream", "&", "cStream", ")", "const", "{", "return", "Fail", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa" ]

[]

[ "<s>", "bool", "aarch_bti_j_insn_p", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "!", "insn", "||", "!", "INSN_P", "(", "insn", ")", ")", "return", "false", ";", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "return", "GET_CODE", "(", "pat", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "pat", ",", "1", ")", "==", "VUNSPEC_BTI_NOP", ";", "}", "</s>" ]

[ "Check", "if", "INSN", "is", "a", "BTI", "J", "insn", "." ]

[ "arm", "1" ]

[]

[ "<s>", "bool", "RISCVAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "!", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "OS", ")", ")", "return", "false", ";", "if", "(", "!", "ExtraCode", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "case", "MachineOperand", "::", "MO_Immediate", ":", "OS", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_Register", ":", "OS", "<<", "RISCVInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", ";", "return", "false", ";", "default", ":", "break", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

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

[]

[ "<s>", "void", "assignValueToReg", "(", "Register", "ValVReg", ",", "Register", "PhysReg", ",", "CCValAssign", "&", "VA", ")", "override", "{", "Register", "ExtReg", ";", "if", "(", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", "<", "32", ")", "{", "ExtReg", "=", "MIRBuilder", ".", "buildAnyExt", "(", "LLT", "::", "scalar", "(", "32", ")", ",", "ValVReg", ")", ".", "getReg", "(", "0", ")", ";", "}", "else", "ExtReg", "=", "extendRegister", "(", "ValVReg", ",", "VA", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "MRI", ".", "getTargetRegisterInfo", "(", ")", ")", ";", "if", "(", "TRI", "->", "isSGPRReg", "(", "MRI", ",", "PhysReg", ")", ")", "{", "auto", "ToSGPR", "=", "MIRBuilder", ".", "buildIntrinsic", "(", "Intrinsic", "::", "amdgcn_readfirstlane", ",", "{", "MRI", ".", "getType", "(", "ExtReg", ")", "}", ",", "false", ")", ".", "addReg", "(", "ExtReg", ")", ";", "ExtReg", "=", "ToSGPR", ".", "getReg", "(", "0", ")", ";", "}", "MIRBuilder", ".", "buildCopy", "(", "PhysReg", ",", "ExtReg", ")", ";", "MIB", ".", "addUse", "(", "PhysReg", ",", "RegState", "::", "Implicit", ")", ";", "}", "</s>" ]

[ "The", "specified", "value", "has", "been", "assigned", "to", "a", "physical", "register", ",", "handle", "the", "appropriate", "COPY", "(", "either", "to", "or", "from", ")", "and", "mark", "any", "relevant", "uses/defines", "as", "needed", "." ]

[ "AMDGPU", "32", "32", "0", "SI", "SI", "Intrinsic::amdgcn_readfirstlane", "0" ]

[]

[ "<s>", "static", "int", "aarch64_simd_clone_compute_vecsize_and_simdlen", "(", "struct", "cgraph_node", "*", "node", ",", "struct", "cgraph_simd_clone", "*", "clonei", ",", "tree", "base_type", ",", "int", "num", ")", "{", "tree", "t", ",", "ret_type", ";", "unsigned", "int", "elt_bits", ",", "count", ";", "unsigned", "HOST_WIDE_INT", "const_simdlen", ";", "poly_uint64", "vec_bits", ";", "if", "(", "!", "TARGET_SIMD", ")", "return", "0", ";", "if", "(", "maybe_ne", "(", "clonei", "->", "simdlen", ",", "0U", ")", "&&", "clonei", "->", "simdlen", ".", "is_constant", "(", "&", "const_simdlen", ")", "&&", "(", "const_simdlen", "<", "2", "||", "const_simdlen", ">", "1024", "||", "(", "const_simdlen", "&", "(", "const_simdlen", "-", "1", ")", ")", "!=", "0", ")", ")", "{", "warning_at", "(", "DECL_SOURCE_LOCATION", "(", "node", "->", "decl", ")", ",", "0", ",", "\"unsupported simdlen %wd\"", ",", "const_simdlen", ")", ";", "return", "0", ";", "}", "ret_type", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "node", "->", "decl", ")", ")", ";", "if", "(", "TREE_CODE", "(", "ret_type", ")", "!=", "VOID_TYPE", "&&", "!", "currently_supported_simd_type", "(", "ret_type", ",", "base_type", ")", ")", "{", "if", "(", "TYPE_SIZE", "(", "ret_type", ")", "!=", "TYPE_SIZE", "(", "base_type", ")", ")", "warning_at", "(", "DECL_SOURCE_LOCATION", "(", "node", "->", "decl", ")", ",", "0", ",", "\"GCC does not currently support mixed size types \"", "\"for %<simd%> functions\"", ")", ";", "else", "if", "(", "supported_simd_type", "(", "ret_type", ")", ")", "warning_at", "(", "DECL_SOURCE_LOCATION", "(", "node", "->", "decl", ")", ",", "0", ",", "\"GCC does not currently support return type %qT \"", "\"for %<simd%> functions\"", ",", "ret_type", ")", ";", "else", "warning_at", "(", "DECL_SOURCE_LOCATION", "(", "node", "->", "decl", ")", ",", "0", ",", "\"unsupported return type %qT for %<simd%> functions\"", ",", "ret_type", ")", ";", "return", "0", ";", "}", "int", "i", ";", "tree", "type_arg_types", "=", "TYPE_ARG_TYPES", "(", "TREE_TYPE", "(", "node", "->", "decl", ")", ")", ";", "bool", "decl_arg_p", "=", "(", "node", "->", "definition", "||", "type_arg_types", "==", "NULL_TREE", ")", ";", "for", "(", "t", "=", "(", "decl_arg_p", "?", "DECL_ARGUMENTS", "(", "node", "->", "decl", ")", ":", "type_arg_types", ")", ",", "i", "=", "0", ";", "t", "&&", "t", "!=", "void_list_node", ";", "t", "=", "TREE_CHAIN", "(", "t", ")", ",", "i", "++", ")", "{", "tree", "arg_type", "=", "decl_arg_p", "?", "TREE_TYPE", "(", "t", ")", ":", "TREE_VALUE", "(", "t", ")", ";", "if", "(", "clonei", "->", "args", "[", "i", "]", ".", "arg_type", "!=", "SIMD_CLONE_ARG_TYPE_UNIFORM", "&&", "!", "currently_supported_simd_type", "(", "arg_type", ",", "base_type", ")", ")", "{", "if", "(", "TYPE_SIZE", "(", "arg_type", ")", "!=", "TYPE_SIZE", "(", "base_type", ")", ")", "warning_at", "(", "DECL_SOURCE_LOCATION", "(", "node", "->", "decl", ")", ",", "0", ",", "\"GCC does not currently support mixed size types \"", "\"for %<simd%> functions\"", ")", ";", "else", "warning_at", "(", "DECL_SOURCE_LOCATION", "(", "node", "->", "decl", ")", ",", "0", ",", "\"GCC does not currently support argument type %qT \"", "\"for %<simd%> functions\"", ",", "arg_type", ")", ";", "return", "0", ";", "}", "}", "clonei", "->", "vecsize_mangle", "=", "'n'", ";", "clonei", "->", "mask_mode", "=", "VOIDmode", ";", "elt_bits", "=", "GET_MODE_BITSIZE", "(", "SCALAR_TYPE_MODE", "(", "base_type", ")", ")", ";", "if", "(", "known_eq", "(", "clonei", "->", "simdlen", ",", "0U", ")", ")", "{", "count", "=", "2", ";", "vec_bits", "=", "(", "num", "==", "0", "?", "64", ":", "128", ")", ";", "clonei", "->", "simdlen", "=", "exact_div", "(", "vec_bits", ",", "elt_bits", ")", ";", "}", "else", "{", "count", "=", "1", ";", "vec_bits", "=", "clonei", "->", "simdlen", "*", "elt_bits", ";", "if", "(", "clonei", "->", "simdlen", ".", "is_constant", "(", "&", "const_simdlen", ")", "&&", "maybe_ne", "(", "vec_bits", ",", "64U", ")", "&&", "maybe_ne", "(", "vec_bits", ",", "128U", ")", ")", "{", "warning_at", "(", "DECL_SOURCE_LOCATION", "(", "node", "->", "decl", ")", ",", "0", ",", "\"GCC does not currently support simdlen %wd for type %qT\"", ",", "const_simdlen", ",", "base_type", ")", ";", "return", "0", ";", "}", "}", "clonei", "->", "vecsize_int", "=", "vec_bits", ";", "clonei", "->", "vecsize_float", "=", "vec_bits", ";", "return", "count", ";", "}", "</s>" ]

[ "Implement", "TARGET_SIMD_CLONE_COMPUTE_VECSIZE_AND_SIMDLEN", "." ]

[ "aarch64", "0", "0U", "2", "1024", "1", "0", "0", "\"unsupported simdlen %wd\"", "0", "0", "\"GCC does not currently support mixed size types \"", "\"for %<simd%> functions\"", "0", "\"GCC does not currently support return type %qT \"", "\"for %<simd%> functions\"", "0", "\"unsupported return type %qT for %<simd%> functions\"", "0", "0", "0", "\"GCC does not currently support mixed size types \"", "\"for %<simd%> functions\"", "0", "\"GCC does not currently support argument type %qT \"", "\"for %<simd%> functions\"", "0", "0U", "2", "0", "64", "128", "1", "64U", "128U", "0", "\"GCC does not currently support simdlen %wd for type %qT\"", "0" ]

[]

[ "<s>", "void", "ARMDAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "if", "(", "!", "Subtarget", "->", "hasV6T2Ops", "(", ")", ")", "return", ";", "bool", "isThumb2", "=", "Subtarget", "->", "isThumb", "(", ")", ";", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "SDNode", "*", "N", "=", "I", "++", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "ADD", ")", "continue", ";", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "N1", "=", "N", "->", "getOperand", "(", "1", ")", ";", "unsigned", "And_imm", "=", "0", ";", "if", "(", "!", "isOpcWithIntImmediate", "(", "N1", ".", "getNode", "(", ")", ",", "ISD", "::", "AND", ",", "And_imm", ")", ")", "{", "if", "(", "isOpcWithIntImmediate", "(", "N0", ".", "getNode", "(", ")", ",", "ISD", "::", "AND", ",", "And_imm", ")", ")", "std", "::", "swap", "(", "N0", ",", "N1", ")", ";", "}", "if", "(", "!", "And_imm", ")", "continue", ";", "unsigned", "TZ", "=", "countTrailingZeros", "(", "And_imm", ")", ";", "if", "(", "TZ", "!=", "1", "&&", "TZ", "!=", "2", ")", "continue", ";", "And_imm", ">>=", "TZ", ";", "if", "(", "And_imm", "&", "(", "And_imm", "+", "1", ")", ")", "continue", ";", "SDValue", "Srl", "=", "N1", ".", "getOperand", "(", "0", ")", ";", "unsigned", "Srl_imm", "=", "0", ";", "if", "(", "!", "isOpcWithIntImmediate", "(", "Srl", ".", "getNode", "(", ")", ",", "ISD", "::", "SRL", ",", "Srl_imm", ")", "||", "(", "Srl_imm", "<=", "2", ")", ")", "continue", ";", "SDValue", "CPTmp0", ";", "SDValue", "CPTmp1", ";", "SDValue", "CPTmp2", ";", "if", "(", "isThumb2", ")", "{", "if", "(", "SelectT2ShifterOperandReg", "(", "N0", ",", "CPTmp0", ",", "CPTmp1", ")", ")", "continue", ";", "}", "else", "{", "if", "(", "SelectImmShifterOperand", "(", "N0", ",", "CPTmp0", ",", "CPTmp1", ")", "||", "SelectRegShifterOperand", "(", "N0", ",", "CPTmp0", ",", "CPTmp1", ",", "CPTmp2", ")", ")", "continue", ";", "}", "Srl", "=", "CurDAG", "->", "getNode", "(", "ISD", "::", "SRL", ",", "SDLoc", "(", "Srl", ")", ",", "MVT", "::", "i32", ",", "Srl", ".", "getOperand", "(", "0", ")", ",", "CurDAG", "->", "getConstant", "(", "Srl_imm", "+", "TZ", ",", "MVT", "::", "i32", ")", ")", ";", "N1", "=", "CurDAG", "->", "getNode", "(", "ISD", "::", "AND", ",", "SDLoc", "(", "N1", ")", ",", "MVT", "::", "i32", ",", "Srl", ",", "CurDAG", "->", "getConstant", "(", "And_imm", ",", "MVT", "::", "i32", ")", ")", ";", "N1", "=", "CurDAG", "->", "getNode", "(", "ISD", "::", "SHL", ",", "SDLoc", "(", "N1", ")", ",", "MVT", "::", "i32", ",", "N1", ",", "CurDAG", "->", "getConstant", "(", "TZ", ",", "MVT", "::", "i32", ")", ")", ";", "CurDAG", "->", "UpdateNodeOperands", "(", "N", ",", "N0", ",", "N1", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "ISD::ADD", "0", "1", "0", "ISD::AND", "ISD::AND", "1", "2", "1", "0", "0", "ISD::SRL", "2", "ISD::SRL", "MVT::i32", "0", "MVT::i32", "ISD::AND", "MVT::i32", "MVT::i32", "ISD::SHL", "MVT::i32", "MVT::i32" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", ",", "unsigned", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "DisablePPCUnaligned", ")", "return", "false", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "if", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "isVector", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "{", "if", "(", "VT", "!=", "MVT", "::", "v2f64", "&&", "VT", "!=", "MVT", "::", "v2i64", ")", "return", "false", ";", "}", "else", "{", "return", "false", ";", "}", "}", "if", "(", "VT", "==", "MVT", "::", "ppcf128", ")", "return", "false", ";", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "PowerPC", "PPC", "PPC", "MVT::v2f64", "MVT::v2i64", "MVT::ppcf128" ]

[]

[ "<s>", "int", "check_use_sfunc_addr", "(", "rtx", "insn", ",", "rtx", "reg", ")", "{", "while", "(", "(", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", ")", "{", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CODE_LABEL", "||", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", ")", "break", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "continue", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SEQUENCE", ")", "insn", "=", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "PARALLEL", "||", "get_attr_type", "(", "insn", ")", "!=", "TYPE_SFUNC", ")", "continue", ";", "return", "rtx_equal_p", "(", "extract_sfunc_addr", "(", "insn", ")", ",", "reg", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Verify", "that", "the", "register", "in", "use_sfunc_addr", "still", "agrees", "with", "the", "address", "used", "in", "the", "sfunc", ".", "This", "prevents", "fill_slots_from_thread", "from", "changing", "use_sfunc_addr", ".", "INSN", "is", "the", "use_sfunc_addr", "instruction", ",", "and", "REG", "is", "the", "register", "it", "guards", "." ]

[ "sh", "0", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"ARM MVE TailPred and VPT Optimisation Pass\"", ";", "}", "</s>" ]

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

[ "ARM", "\"ARM MVE TailPred and VPT Optimisation Pass\"" ]

[]

[ "<s>", "static", "void", "tilepro_setup_incoming_varargs", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_args", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "local_cum", "=", "*", "get_cumulative_args", "(", "cum", ")", ";", "int", "first_reg", ";", "targetm", ".", "calls", ".", "function_arg_advance", "(", "pack_cumulative_args", "(", "&", "local_cum", ")", ",", "arg", ")", ";", "first_reg", "=", "local_cum", ";", "if", "(", "local_cum", "<", "TILEPRO_NUM_ARG_REGS", ")", "{", "*", "pretend_args", "=", "UNITS_PER_WORD", "*", "(", "TILEPRO_NUM_ARG_REGS", "-", "first_reg", ")", ";", "if", "(", "!", "no_rtl", ")", "{", "alias_set_type", "set", "=", "get_varargs_alias_set", "(", ")", ";", "rtx", "tmp", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "\\", "virtual_incoming_args_rtx", ",", "-", "STACK_POINTER_OFFSET", "-", "UNITS_PER_WORD", "*", "(", "TILEPRO_NUM_ARG_REGS", "-", "first_reg", ")", ")", ")", ";", "MEM_NOTRAP_P", "(", "tmp", ")", "=", "1", ";", "set_mem_alias_set", "(", "tmp", ",", "set", ")", ";", "move_block_from_reg", "(", "first_reg", ",", "tmp", ",", "TILEPRO_NUM_ARG_REGS", "-", "first_reg", ")", ";", "}", "}", "else", "*", "pretend_args", "=", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_SETUP_INCOMING_VARARGS", "." ]

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

[]

[ "<s>", "unsigned", "AMDGPURegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "AMDGPU", "::", "NoRegister", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::NoRegister" ]

[]

[ "<s>", "bool", "legitimate_constant_address_p", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "CONST_INT_P", "(", "x", ")", "||", "GET_CODE", "(", "x", ")", "==", "HIGH", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "CONST", ")", "return", "false", ";", "if", "(", "flag_pic", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "!", "SYMBOL_REF_LOCAL_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "1", "if", "X", "is", "an", "rtx", "for", "a", "constant", "that", "is", "a", "valid", "address", "." ]

[ "vax", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "s390_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "cxt", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "rtx", "mem", ";", "emit_block_move", "(", "m_tramp", ",", "assemble_trampoline_template", "(", ")", ",", "GEN_INT", "(", "2", "*", "UNITS_PER_LONG", ")", ",", "BLOCK_OP_NORMAL", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "2", "*", "UNITS_PER_LONG", ")", ";", "emit_move_insn", "(", "mem", ",", "cxt", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "3", "*", "UNITS_PER_LONG", ")", ";", "emit_move_insn", "(", "mem", ",", "fnaddr", ")", ";", "}", "</s>" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", ".", "FNADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "function", "'s", "pure", "code", ".", "CXT", "is", "an", "RTX", "for", "the", "static", "chain", "value", "for", "the", "function", "." ]

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

[]

[ "<s>", "char", "*", "ix86_offload_options", "(", "void", ")", "{", "if", "(", "TARGET_LP64", ")", "return", "xstrdup", "(", "\"-foffload-abi=lp64\"", ")", ";", "return", "xstrdup", "(", "\"-foffload-abi=ilp32\"", ")", ";", "}", "</s>" ]

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

[ "i386", "\"-foffload-abi=lp64\"", "\"-foffload-abi=ilp32\"" ]

[]

[ "<s>", "void", "SICDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "if", "(", "trySelect", "(", "Node", ")", ")", "return", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "ReplaceNode", "(", "Node", ",", "getGlobalBaseReg", "(", ")", ")", ";", "return", ";", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "SIC", "SIC", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "1", "ISD::GLOBAL_OFFSET_TABLE" ]

[]

[ "<s>", "const", "char", "*", "ix86_output_call_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "call_op", ")", "{", "bool", "direct_p", "=", "constant_call_address_operand", "(", "call_op", ",", "VOIDmode", ")", ";", "bool", "seh_nop_p", "=", "false", ";", "const", "char", "*", "xasm", ";", "if", "(", "SIBLING_CALL_P", "(", "insn", ")", ")", "{", "if", "(", "direct_p", ")", "{", "if", "(", "ix86_nopic_noplt_attribute_p", "(", "call_op", ")", ")", "{", "if", "(", "TARGET_64BIT", ")", "xasm", "=", "\"%!jmp\\t{*%p0@GOTPCREL(%%rip)|[QWORD PTR %p0@GOTPCREL[rip]]}\"", ";", "else", "xasm", "=", "\"%!jmp\\t{*%p0@GOT|[DWORD PTR %p0@GOT]}\"", ";", "}", "else", "xasm", "=", "\"%!jmp\\t%P0\"", ";", "}", "else", "if", "(", "TARGET_SEH", ")", "xasm", "=", "\"%!rex.W jmp\\t%A0\"", ";", "else", "xasm", "=", "\"%!jmp\\t%A0\"", ";", "output_asm_insn", "(", "xasm", ",", "&", "call_op", ")", ";", "return", "\"\"", ";", "}", "if", "(", "TARGET_SEH", ")", "{", "rtx_insn", "*", "i", ";", "for", "(", "i", "=", "NEXT_INSN", "(", "insn", ")", ";", "i", ";", "i", "=", "NEXT_INSN", "(", "i", ")", ")", "{", "if", "(", "INSN_P", "(", "i", ")", ")", "break", ";", "if", "(", "NOTE_P", "(", "i", ")", "&&", "NOTE_KIND", "(", "i", ")", "==", "NOTE_INSN_EPILOGUE_BEG", "&&", "!", "flag_non_call_exceptions", "&&", "!", "can_throw_internal", "(", "insn", ")", ")", "{", "seh_nop_p", "=", "true", ";", "break", ";", "}", "}", "if", "(", "i", "==", "NULL", ")", "seh_nop_p", "=", "true", ";", "}", "if", "(", "direct_p", ")", "{", "if", "(", "ix86_nopic_noplt_attribute_p", "(", "call_op", ")", ")", "{", "if", "(", "TARGET_64BIT", ")", "xasm", "=", "\"%!call\\t{*%p0@GOTPCREL(%%rip)|[QWORD PTR %p0@GOTPCREL[rip]]}\"", ";", "else", "xasm", "=", "\"%!call\\t{*%p0@GOT|[DWORD PTR %p0@GOT]}\"", ";", "}", "else", "xasm", "=", "\"%!call\\t%P0\"", ";", "}", "else", "xasm", "=", "\"%!call\\t%A0\"", ";", "output_asm_insn", "(", "xasm", ",", "&", "call_op", ")", ";", "if", "(", "seh_nop_p", ")", "return", "\"nop\"", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "the", "assembly", "for", "a", "call", "instruction", "." ]

[ "i386", "\"%!jmp\\t{*%p0@GOTPCREL(%%rip)|[QWORD PTR %p0@GOTPCREL[rip]]}\"", "\"%!jmp\\t{*%p0@GOT|[DWORD PTR %p0@GOT]}\"", "\"%!jmp\\t%P0\"", "\"%!rex.W jmp\\t%A0\"", "\"%!jmp\\t%A0\"", "\"\"", "\"%!call\\t{*%p0@GOTPCREL(%%rip)|[QWORD PTR %p0@GOTPCREL[rip]]}\"", "\"%!call\\t{*%p0@GOT|[DWORD PTR %p0@GOT]}\"", "\"%!call\\t%P0\"", "\"%!call\\t%A0\"", "\"nop\"", "\"\"" ]

[]

[ "<s>", "MachineBasicBlock", "*", "HexagonTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "Hexagon", "::", "ADJDYNALLOC", ":", "{", "MachineFunction", "*", "MF", "=", "BB", "->", "getParent", "(", ")", ";", "HexagonMachineFunctionInfo", "*", "FuncInfo", "=", "MF", "->", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", ";", "FuncInfo", "->", "addAllocaAdjustInst", "(", "MI", ")", ";", "return", "BB", ";", "}", "default", ":", "assert", "(", "false", "&&", "\"Unexpected instr type to insert\"", ")", ";", "}", "return", "NULL", ";", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "Hexagon", "Hexagon", "Hexagon::ADJDYNALLOC", "Hexagon", "Hexagon", "\"Unexpected instr type to insert\"" ]

[]

[ "<s>", "bool", "WebAssemblyStoreResults", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Store Results **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "MachineDominatorTree", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "WebAssemblyTargetLowering", "&", "TLI", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", ";", "const", "auto", "&", "LibInfo", "=", "getAnalysis", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ".", "getTLI", "(", ")", ";", "LiveIntervals", "&", "LIS", "=", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "bool", "Changed", "=", "false", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "assert", "(", "MRI", ".", "tracksLiveness", "(", ")", "&&", "\"StoreResults expects liveness tracking\"", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Basic Block: \"", "<<", "MBB", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "WebAssembly", "::", "CALL_I32", ":", "case", "WebAssembly", "::", "CALL_I64", ":", "Changed", "|=", "optimizeCall", "(", "MBB", ",", "MI", ",", "MRI", ",", "MDT", ",", "LIS", ",", "TLI", ",", "LibInfo", ")", ";", "break", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Store Results **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "\"StoreResults expects liveness tracking\"", "\"Basic Block: \"", "WebAssembly::CALL_I32", "WebAssembly::CALL_I64" ]

[]

[ "<s>", "bool", "ARMBaseTargetMachine", "::", "addInstSelector", "(", "PassManagerBase", "&", "PM", ")", "{", "PM", ".", "add", "(", "createARMISelDag", "(", "*", "this", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "releaseMemory", "(", ")", "override", "{", "}", "</s>" ]

[ "releaseMemory", "(", ")", "-", "This", "member", "can", "be", "implemented", "by", "a", "pass", "if", "it", "wants", "to", "be", "able", "to", "release", "its", "memory", "when", "it", "is", "no", "longer", "needed", "." ]

[ "JVM" ]

[]

[ "<s>", "bool", "SystemZTargetLowering", "::", "isTruncateFree", "(", "EVT", "FromVT", ",", "EVT", "ToVT", ")", "const", "{", "if", "(", "!", "FromVT", ".", "isInteger", "(", ")", "||", "!", "ToVT", ".", "isInteger", "(", ")", ")", "return", "false", ";", "unsigned", "FromBits", "=", "FromVT", ".", "getFixedSizeInBits", "(", ")", ";", "unsigned", "ToBits", "=", "ToVT", ".", "getFixedSizeInBits", "(", ")", ";", "return", "FromBits", ">", "ToBits", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "void", "ix86_emit_fp_unordered_jump", "(", "rtx", "label", ")", "{", "rtx", "reg", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "rtx_insn", "*", "insn", ";", "rtx", "temp", ";", "emit_insn", "(", "gen_x86_fnstsw_1", "(", "reg", ")", ")", ";", "if", "(", "TARGET_SAHF", "&&", "(", "TARGET_USE_SAHF", "||", "optimize_insn_for_size_p", "(", ")", ")", ")", "{", "emit_insn", "(", "gen_x86_sahf_1", "(", "reg", ")", ")", ";", "temp", "=", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ";", "temp", "=", "gen_rtx_UNORDERED", "(", "VOIDmode", ",", "temp", ",", "const0_rtx", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_testqi_ext_1_ccno", "(", "reg", ",", "GEN_INT", "(", "0x04", ")", ")", ")", ";", "temp", "=", "gen_rtx_REG", "(", "CCNOmode", ",", "FLAGS_REG", ")", ";", "temp", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "temp", ",", "const0_rtx", ")", ";", "}", "temp", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "temp", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label", ")", ",", "pc_rtx", ")", ";", "insn", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "temp", ")", ")", ";", "predict_jump", "(", "REG_BR_PROB_BASE", "*", "10", "/", "100", ")", ";", "JUMP_LABEL", "(", "insn", ")", "=", "label", ";", "}", "</s>" ]

[ "Output", "code", "to", "perform", "a", "conditional", "jump", "to", "LABEL", ",", "if", "C2", "flag", "in", "FP", "status", "register", "is", "set", "." ]

[ "i386", "0x04", "10", "100" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequired", "<", "AliasAnalysis", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "Patmos" ]

[]

[ "<s>", "bool", "M68kInstrInfo", "::", "isPCRelRegisterOperandLegal", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "assert", "(", "MO", ".", "isReg", "(", ")", ")", ";", "const", "MachineInstr", "*", "MI", "=", "MO", ".", "getParent", "(", ")", ";", "const", "unsigned", "NameIndices", "=", "M68kInstrNameIndices", "[", "MI", "->", "getOpcode", "(", ")", "]", ";", "StringRef", "InstrName", "(", "&", "M68kInstrNameData", "[", "NameIndices", "]", ")", ";", "const", "unsigned", "OperandNo", "=", "MI", "->", "getOperandNo", "(", "&", "MO", ")", ";", "if", "(", "OperandNo", "==", "1", ")", "return", "Regex", "(", "\"[A-Z]+(8|16|32)k[a-z](_TC)?$\"", ")", ".", "match", "(", "InstrName", ")", ";", "if", "(", "OperandNo", "==", "MI", "->", "getNumExplicitOperands", "(", ")", "-", "1", ")", "return", "Regex", "(", "\"[A-Z]+(8|16|32)[a-z]k(_TC)?$\"", ")", ".", "match", "(", "InstrName", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Allow", "targets", "to", "tell", "MachineVerifier", "whether", "a", "specific", "register", "MachineOperand", "can", "be", "used", "as", "part", "of", "PC-relative", "addressing", "." ]

[ "M68k", "M68k", "M68k", "M68k", "1", "\"[A-Z]+(8|16|32)k[a-z](_TC)?$\"", "1", "\"[A-Z]+(8|16|32)[a-z]k(_TC)?$\"" ]

[]

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

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

[ "LEG", "LEG", "LEG::MOVrr" ]

[]

[ "<s>", "bool", "BPFAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "if", "(", "(", "Count", "%", "8", ")", "!=", "0", ")", "return", "false", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "Count", ";", "i", "+=", "8", ")", "support", "::", "endian", "::", "write", "<", "uint64_t", ">", "(", "OS", ",", "0x15000000", ",", "Endian", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "8", "0", "0", "8", "support::endian", "0x15000000" ]

[]

[ "<s>", "AsmToken", "LexToken", "(", ")", "{", "if", "(", "!", "Lexer", ")", "{", "SetError", "(", "SMLoc", "(", ")", ",", "\"No MCAsmLexer installed\"", ")", ";", "return", "AsmToken", "(", "AsmToken", "::", "Error", ",", "\"\"", ",", "0", ")", ";", "}", "switch", "(", "AsmInfo", ".", "getAssemblerDialect", "(", ")", ")", "{", "default", ":", "SetError", "(", "SMLoc", "(", ")", ",", "\"Unhandled dialect\"", ")", ";", "return", "AsmToken", "(", "AsmToken", "::", "Error", ",", "\"\"", ",", "0", ")", ";", "case", "0", ":", "return", "LexTokenATT", "(", ")", ";", "case", "1", ":", "return", "LexTokenIntel", "(", ")", ";", "}", "}", "</s>" ]

[ "LexToken", "-", "Read", "the", "next", "token", "and", "return", "its", "code", "." ]

[ "X86", "\"No MCAsmLexer installed\"", "\"\"", "0", "\"Unhandled dialect\"", "\"\"", "0", "0", "1" ]

[]

[ "<s>", "BitVector", "Z80oldRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "Z80oldFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "Reserved", ".", "set", "(", "Z80old", "::", "SPS", ")", ";", "Reserved", ".", "set", "(", "Z80old", "::", "PC", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "for", "(", "MCSubRegIterator", "I", "(", "Z80old", "::", "IX", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "{", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "Z80old", "Z80old", "Z80old", "Z80old::SPS", "Z80old::PC", "Z80old::IX" ]

[]

[ "<s>", "bool", "hasExtractInsert", "(", ")", "const", "{", "return", "!", "inMips16Mode", "(", ")", "&&", "hasMips32r2", "(", ")", ";", "}", "</s>" ]

[ "Features", "related", "to", "the", "presence", "of", "specific", "instructions", "." ]

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

[]

[ "<s>", "static", "void", "alpha_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "bool", "onstack", "=", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "arg", ")", ";", "int", "increment", "=", "onstack", "?", "6", ":", "ALPHA_ARG_SIZE", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "*", "cum", "+=", "increment", ";", "if", "(", "!", "onstack", "&&", "cum", "->", "num_args", "<", "6", ")", "cum", "->", "atypes", "[", "cum", "->", "num_args", "]", "=", "alpha_arg_type", "(", "arg", ".", "mode", ")", ";", "cum", "->", "num_args", "+=", "increment", ";", "}", "</s>" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")" ]

[ "alpha", "6", "6" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "nvptx_init_machine_status", "(", "void", ")", "{", "struct", "machine_function", "*", "p", "=", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "p", "->", "ret_reg_mode", "=", "VOIDmode", ";", "return", "p", ";", "}", "</s>" ]

[ "Allocate", "a", "new", ",", "cleared", "machine_function", "structure", "." ]

[ "nvptx" ]

[]

[ "<s>", "unsigned", "AAPInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "TBB", "&&", "\"InsertBranch cannot insert a fallthrough\"", ")", ";", "assert", "(", "Cond", ".", "size", "(", ")", "==", "3", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", ";", "MachineInstr", "*", "MI", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FBB", "&&", "\"Unconditional branch cannot have multiple successors\"", ")", ";", "MI", "=", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AAP", "::", "BRA", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "*", "MI", ")", ";", "return", "1", ";", "}", "unsigned", "Count", "=", "0", ";", "AAPCC", "::", "CondCode", "CC", "=", "(", "AAPCC", "::", "CondCode", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "MI", "=", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "getBranchOpcodeFromCond", "(", "CC", ")", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addReg", "(", "Cond", "[", "1", "]", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "Cond", "[", "2", "]", ".", "getReg", "(", ")", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "*", "MI", ")", ";", "++", "Count", ";", "if", "(", "FBB", ")", "{", "MI", "=", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AAP", "::", "BRA", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "*", "MI", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "AAP", "AAP", "\"InsertBranch cannot insert a fallthrough\"", "3", "0", "\"Unconditional branch cannot have multiple successors\"", "AAP::BRA", "1", "0", "AAPCC::CondCode", "AAPCC::CondCode", "0", "1", "2", "AAP::BRA" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"ARM Machine Code Emitter\"", ";", "}", "</s>" ]

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

[ "ARM", "\"ARM Machine Code Emitter\"" ]

[]

[ "<s>", "bool", "hasDomain", "(", "unsigned", "domain", ")", "const", "{", "return", "AvailableDomains", "&", "(", "1u", "<<", "domain", ")", ";", "}", "</s>" ]

[ "Is", "domain", "available", "?" ]

[ "X86", "1u" ]

[]

[ "<s>", "void", "ARMAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "EnableMCInst", ")", "{", "printInstructionThroughMCStreamer", "(", "MI", ")", ";", "return", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "CONSTPOOL_ENTRY", ")", "EmitAlignment", "(", "2", ")", ";", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "OS", ".", "str", "(", ")", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2TBB", ")", "EmitAlignment", "(", "1", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::CONSTPOOL_ENTRY", "2", "128", "ARM::t2TBB", "1" ]

[]

[ "<s>", "static", "bool", "isEqual", "(", "const", "CvtDirection", "&", "LHS", ",", "const", "CvtDirection", "&", "RHS", ")", "{", "return", "LHS", ".", "SourceType", "==", "RHS", ".", "SourceType", "&&", "LHS", ".", "DestinationType", "==", "RHS", ".", "DestinationType", ";", "}", "</s>" ]

[ "isEqual", "-", "Compares", "two", "trees", "for", "structural", "equality", "and", "returns", "true", "if", "they", "are", "equal", "." ]

[ "TPC" ]

[]

[ "<s>", "static", "void", "arc_internal_label", "(", "FILE", "*", "stream", ",", "const", "char", "*", "prefix", ",", "unsigned", "long", "labelno", ")", "{", "arc_ccfsm_at_label", "(", "prefix", ",", "labelno", ")", ";", "default_internal_label", "(", "stream", ",", "prefix", ",", "labelno", ")", ";", "}", "</s>" ]

[ "This", "is", "how", "to", "output", "a", "definition", "of", "an", "internal", "numbered", "label", "where", "PREFIX", "is", "the", "class", "of", "label", "and", "NUM", "is", "the", "number", "within", "the", "class", "." ]

[ "arc" ]

[]