Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "Z80InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "Z80", "::", "GR8RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Z80", "::", "LD8rr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "else", "if", "(", "Z80", "::", "BR16RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "if", "(", "Z80", "::", "EXR16RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", "&&", "KillSrc", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Z80", "::", "EX_DE_HL", ")", ")", ";", "}", "else", "{", "unsigned", "DestSubReg", ",", "SrcSubReg", ";", "DestSubReg", "=", "RI", ".", "getSubReg", "(", "DestReg", ",", "Z80", "::", "subreg_hi", ")", ";", "SrcSubReg", "=", "RI", ".", "getSubReg", "(", "SrcReg", ",", "Z80", "::", "subreg_hi", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Z80", "::", "LD8rr", ")", ",", "DestSubReg", ")", ".", "addReg", "(", "SrcSubReg", ")", ";", "DestSubReg", "=", "RI", ".", "getSubReg", "(", "DestReg", ",", "Z80", "::", "subreg_lo", ")", ";", "SrcSubReg", "=", "RI", ".", "getSubReg", "(", "SrcReg", ",", "Z80", "::", "subreg_lo", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Z80", "::", "LD8rr", ")", ",", "DestSubReg", ")", ".", "addReg", "(", "SrcSubReg", ")", ";", "}", "if", "(", "KillSrc", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Z80", "::", "KILL", ")", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "else", "if", "(", "Z80", "::", "GR16RegClass", ".", "contains", "(", "DestReg", ")", "||", "Z80", "::", "GR16RegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Z80", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Z80", "::", "POP16r", ")", ",", "DestReg", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "\"Imposible reg-to-reg copy\"", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "Z80::GR8RegClass", "Z80::LD8rr", "Z80::BR16RegClass", "Z80::EXR16RegClass", "Z80::EX_DE_HL", "Z80::subreg_hi", "Z80::subreg_hi", "Z80::LD8rr", "Z80::subreg_lo", "Z80::subreg_lo", "Z80::LD8rr", "Z80::KILL", "Z80::GR16RegClass", "Z80::GR16RegClass", "Z80::PUSH16r", "Z80::POP16r", "\"Imposible reg-to-reg copy\"" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "getSqrtEstimate", "(", "SDValue", "Operand", ",", "SelectionDAG", "&", "DAG", ",", "int", "Enabled", ",", "int", "&", "ExtraSteps", ",", "bool", "&", "UseOneConst", ",", "bool", "Reciprocal", ")", "const", "{", "if", "(", "Enabled", "==", "ReciprocalEstimate", "::", "Enabled", "||", "(", "Enabled", "==", "ReciprocalEstimate", "::", "Unspecified", "&&", "Subtarget", "->", "useRSqrt", "(", ")", ")", ")", "if", "(", "SDValue", "Estimate", "=", "getEstimate", "(", "Subtarget", ",", "AArch64ISD", "::", "FRSQRTE", ",", "Operand", ",", "DAG", ",", "ExtraSteps", ")", ")", "{", "SDLoc", "DL", "(", "Operand", ")", ";", "EVT", "VT", "=", "Operand", ".", "getValueType", "(", ")", ";", "SDNodeFlags", "Flags", ";", "Flags", ".", "setAllowReassociation", "(", "true", ")", ";", "for", "(", "int", "i", "=", "ExtraSteps", ";", "i", ">", "0", ";", "--", "i", ")", "{", "SDValue", "Step", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "DL", ",", "VT", ",", "Estimate", ",", "Estimate", ",", "Flags", ")", ";", "Step", "=", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "FRSQRTS", ",", "DL", ",", "VT", ",", "Operand", ",", "Step", ",", "Flags", ")", ";", "Estimate", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "DL", ",", "VT", ",", "Estimate", ",", "Step", ",", "Flags", ")", ";", "}", "if", "(", "!", "Reciprocal", ")", "Estimate", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "DL", ",", "VT", ",", "Operand", ",", "Estimate", ",", "Flags", ")", ";", "ExtraSteps", "=", "0", ";", "return", "Estimate", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Hooks", "for", "building", "estimates", "in", "place", "of", "slower", "divisions", "and", "square", "roots", "." ]

[ "AArch64", "AArch64", "AArch64ISD::FRSQRTE", "0", "ISD::FMUL", "AArch64ISD::FRSQRTS", "ISD::FMUL", "ISD::FMUL", "0" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalMaskedLoad", "(", "Type", "*", "DataTy", ")", "{", "Type", "*", "ScalarTy", "=", "DataTy", "->", "getScalarType", "(", ")", ";", "int", "DataWidth", "=", "isa", "<", "PointerType", ">", "(", "ScalarTy", ")", "?", "DL", ".", "getPointerSizeInBits", "(", ")", ":", "ScalarTy", "->", "getPrimitiveSizeInBits", "(", ")", ";", "return", "(", "DataWidth", ">=", "32", "&&", "ST", "->", "hasAVX2", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "load", "." ]

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

[]

[ "<s>", "static", "machine_mode", "rs6000_translate_mode_attribute", "(", "machine_mode", "mode", ")", "{", "if", "(", "(", "FLOAT128_IEEE_P", "(", "mode", ")", "&&", "ieee128_float_type_node", "==", "long_double_type_node", ")", "||", "(", "FLOAT128_IBM_P", "(", "mode", ")", "&&", "ibm128_float_type_node", "==", "long_double_type_node", ")", ")", "return", "COMPLEX_MODE_P", "(", "mode", ")", "?", "E_TCmode", ":", "E_TFmode", ";", "return", "mode", ";", "}", "</s>" ]

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

[ "rs6000" ]

[]

[ "<s>", "unsigned", "int", "rs6000_debugger_regno", "(", "unsigned", "int", "regno", ",", "unsigned", "int", "format", ")", "{", "if", "(", "(", "format", "==", "0", "&&", "dwarf_debuginfo_p", "(", ")", ")", "||", "format", "==", "1", ")", "{", "if", "(", "regno", "<=", "31", ")", "return", "regno", ";", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "return", "regno", "-", "FIRST_FPR_REGNO", "+", "32", ";", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "return", "regno", "-", "FIRST_ALTIVEC_REGNO", "+", "1124", ";", "if", "(", "regno", "==", "LR_REGNO", ")", "return", "108", ";", "if", "(", "regno", "==", "CTR_REGNO", ")", "return", "109", ";", "if", "(", "regno", "==", "CA_REGNO", ")", "return", "101", ";", "if", "(", "format", "==", "1", "&&", "regno", "==", "CR2_REGNO", ")", "return", "64", ";", "if", "(", "CR_REGNO_P", "(", "regno", ")", ")", "return", "regno", "-", "CR0_REGNO", "+", "86", ";", "if", "(", "regno", "==", "VRSAVE_REGNO", ")", "return", "356", ";", "if", "(", "regno", "==", "VSCR_REGNO", ")", "return", "67", ";", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", ")", "return", "111", ";", "if", "(", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "67", ";", "if", "(", "regno", "==", "64", ")", "return", "100", ";", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "regno", "<=", "31", ")", "return", "regno", ";", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "return", "regno", "-", "FIRST_FPR_REGNO", "+", "32", ";", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "return", "regno", "-", "FIRST_ALTIVEC_REGNO", "+", "77", ";", "if", "(", "regno", "==", "LR_REGNO", ")", "return", "65", ";", "if", "(", "regno", "==", "CTR_REGNO", ")", "return", "66", ";", "if", "(", "regno", "==", "CA_REGNO", ")", "return", "76", ";", "if", "(", "CR_REGNO_P", "(", "regno", ")", ")", "return", "regno", "-", "CR0_REGNO", "+", "68", ";", "if", "(", "regno", "==", "VRSAVE_REGNO", ")", "return", "109", ";", "if", "(", "regno", "==", "VSCR_REGNO", ")", "return", "110", ";", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", ")", "return", "111", ";", "if", "(", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "67", ";", "if", "(", "regno", "==", "64", ")", "return", "64", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Map", "internal", "gcc", "register", "numbers", "to", "debug", "format", "register", "numbers", ".", "FORMAT", "specifies", "the", "type", "of", "debug", "register", "number", "to", "use", ":", "0", "--", "debug", "information", ",", "except", "for", "frame-related", "sections", "1", "--", "DWARF", ".debug_frame", "section", "2", "--", "DWARF", ".eh_frame", "section" ]

[ "rs6000", "0", "1", "31", "32", "1124", "108", "109", "101", "1", "64", "86", "356", "67", "111", "67", "64", "100", "31", "32", "77", "65", "66", "76", "68", "109", "110", "111", "67", "64", "64" ]

[]

[ "<s>", "void", "AArch64RegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "Register", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "StackOffset", "Off", "(", "Offset", ",", "MVT", "::", "i8", ")", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "AArch64InstrInfo", "*", "TII", "=", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "Done", "=", "rewriteAArch64FrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "assert", "(", "Done", "&&", "\"Unable to resolve frame index!\"", ")", ";", "(", "void", ")", "Done", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "AArch64", "AArch64", "MVT::i8", "0", "\"Instr doesn't have FrameIndex operand!\"", "AArch64", "AArch64", "AArch64", "\"Unable to resolve frame index!\"" ]

[]

[ "<s>", "void", "ARMConstantIslands", "::", "verify", "(", ")", "{", "for", "(", "MachineFunction", "::", "iterator", "MBBI", "=", "MF", "->", "begin", "(", ")", ",", "E", "=", "MF", "->", "end", "(", ")", ";", "MBBI", "!=", "E", ";", "++", "MBBI", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "MBBI", ";", "unsigned", "Align", "=", "MBB", "->", "getAlignment", "(", ")", ";", "unsigned", "MBBId", "=", "MBB", "->", "getNumber", "(", ")", ";", "assert", "(", "BBInfo", "[", "MBBId", "]", ".", "Offset", "%", "(", "1u", "<<", "Align", ")", "==", "0", ")", ";", "assert", "(", "!", "MBBId", "||", "BBInfo", "[", "MBBId", "-", "1", "]", ".", "postOffset", "(", ")", "<=", "BBInfo", "[", "MBBId", "]", ".", "Offset", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CPUsers", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CPUser", "&", "U", "=", "CPUsers", "[", "i", "]", ";", "unsigned", "UserOffset", "=", "GetUserOffset", "(", "U", ")", ";", "assert", "(", "CPEIsInRange", "(", "U", ".", "MI", ",", "UserOffset", ",", "U", ".", "CPEMI", ",", "U", ".", "getMaxDisp", "(", ")", ",", "U", ".", "NegOk", ")", "&&", "\"Constant pool entry out of range!\"", ")", ";", "}", "}", "</s>" ]

[ "Check", "if", "this", "register", "bank", "is", "valid", "." ]

[ "ARM", "ARM", "1u", "0", "1", "0", "\"Constant pool entry out of range!\"" ]

[]

[ "<s>", "void", "riscv_move_integer", "(", "rtx", "temp", ",", "rtx", "dest", ",", "HOST_WIDE_INT", "value", ",", "machine_mode", "orig_mode", ",", "bool", "in_splitter", ")", "{", "struct", "riscv_integer_op", "codes", "[", "RISCV_MAX_INTEGER_OPS", "]", ";", "machine_mode", "mode", ";", "int", "i", ",", "num_ops", ";", "rtx", "x", ";", "bool", "can_create_pseudo", "=", "can_create_pseudo_p", "(", ")", "&&", "!", "in_splitter", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "num_ops", "=", "riscv_build_integer", "(", "codes", ",", "value", ",", "orig_mode", ")", ";", "if", "(", "can_create_pseudo", "&&", "num_ops", ">", "2", "&&", "num_ops", ">=", "riscv_split_integer_cost", "(", "value", ")", ")", "x", "=", "riscv_split_integer", "(", "value", ",", "mode", ")", ";", "else", "{", "x", "=", "GEN_INT", "(", "codes", "[", "0", "]", ".", "value", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<", "num_ops", ";", "i", "++", ")", "{", "if", "(", "!", "can_create_pseudo", ")", "x", "=", "riscv_emit_set", "(", "temp", ",", "x", ")", ";", "else", "x", "=", "force_reg", "(", "mode", ",", "x", ")", ";", "x", "=", "gen_rtx_fmt_ee", "(", "codes", "[", "i", "]", ".", "code", ",", "mode", ",", "x", ",", "GEN_INT", "(", "codes", "[", "i", "]", ".", "value", ")", ")", ";", "}", "}", "riscv_emit_set", "(", "dest", ",", "x", ")", ";", "}", "</s>" ]

[ "Load", "VALUE", "into", "DEST", ".", "TEMP", "is", "as", "for", "riscv_force_temporary", "." ]

[ "riscv", "2", "0", "1" ]

[]

[ "<s>", "static", "int", "thumb_far_jump_used_p", "(", "void", ")", "{", "rtx", "insn", ";", "if", "(", "cfun", "->", "machine", "->", "far_jump_used", ")", "return", "1", ";", "if", "(", "!", "(", "ARM_DOUBLEWORD_ALIGN", "||", "reload_completed", ")", ")", "{", "if", "(", "regs_ever_live", "[", "ARG_POINTER_REGNUM", "]", ")", "cfun", "->", "machine", "->", "arg_pointer_live", "=", "1", ";", "else", "if", "(", "!", "cfun", "->", "machine", "->", "arg_pointer_live", ")", "return", "0", ";", "}", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_VEC", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_DIFF_VEC", "&&", "get_attr_far_jump", "(", "insn", ")", "==", "FAR_JUMP_YES", ")", "{", "cfun", "->", "machine", "->", "far_jump_used", "=", "1", ";", "return", "1", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Returns", "non-zero", "if", "the", "current", "function", "contains", ",", "or", "might", "contain", "a", "far", "jump", "." ]

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

[]

[ "<s>", "long", "long", "rs6000_const_f32_to_i32", "(", "rtx", "operand", ")", "{", "long", "long", "value", ";", "const", "struct", "real_value", "*", "rv", "=", "CONST_DOUBLE_REAL_VALUE", "(", "operand", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "operand", ")", "==", "SFmode", ")", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "*", "rv", ",", "value", ")", ";", "return", "value", ";", "}", "</s>" ]

[ "Convert", "a", "SFmode", "constant", "to", "the", "integer", "bit", "pattern", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "&", "MI", ",", "AAResults", "*", "AA", ")", "const", "{", "if", "(", "isVOP1", "(", "MI", ")", "||", "isVOP2", "(", "MI", ")", "||", "isVOP3", "(", "MI", ")", "||", "isSDWA", "(", "MI", ")", "||", "isSALU", "(", "MI", ")", ")", "{", "return", "!", "MI", ".", "hasImplicitDef", "(", ")", "&&", "MI", ".", "getNumImplicitOperands", "(", ")", "==", "MI", ".", "getDesc", "(", ")", ".", "getNumImplicitUses", "(", ")", "&&", "!", "MI", ".", "mayRaiseFPException", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "For", "instructions", "with", "opcodes", "for", "which", "the", "M_REMATERIALIZABLE", "flag", "is", "set", ",", "this", "hook", "lets", "the", "target", "specify", "whether", "the", "instruction", "is", "actually", "trivially", "rematerializable", ",", "taking", "into", "consideration", "its", "operands", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "StringRef", "RISCVMCExpr", "::", "getVariantKindName", "(", "VariantKind", "Kind", ")", "{", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid ELF symbol kind\"", ")", ";", "case", "VK_RISCV_LO", ":", "return", "\"lo\"", ";", "case", "VK_RISCV_HI", ":", "return", "\"hi\"", ";", "case", "VK_RISCV_PCREL_HI", ":", "return", "\"pcrel_hi\"", ";", "}", "}", "</s>" ]

[ "Convert", "the", "variant", "kind", "into", "an", "ELF-appropriate", "modifier", "(", "e.g", "." ]

[ "RISCV", "RISCV", "\"Invalid ELF symbol kind\"", "RISCV", "\"lo\"", "RISCV", "\"hi\"", "RISCV", "\"pcrel_hi\"" ]

[]

[ "<s>", "rtx", "legitimize_pic_address", "(", "rtx", "orig", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "reg", ")", "{", "rtx", "pic_ref", "=", "orig", ";", "if", "(", "GET_CODE", "(", "orig", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "orig", ")", "==", "LABEL_REF", ")", "{", "gcc_assert", "(", "reg", ")", ";", "pic_ref", "=", "gen_rtx_MEM", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "pic_offset_table_rtx", ",", "orig", ")", ")", ";", "current_function_uses_pic_offset_table", "=", "1", ";", "MEM_READONLY_P", "(", "pic_ref", ")", "=", "1", ";", "emit_move_insn", "(", "reg", ",", "pic_ref", ")", ";", "return", "reg", ";", "}", "else", "if", "(", "GET_CODE", "(", "orig", ")", "==", "CONST", ")", "{", "rtx", "base", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "orig", ",", "0", ")", ")", "==", "PLUS", "&&", "XEXP", "(", "XEXP", "(", "orig", ",", "0", ")", ",", "0", ")", "==", "pic_offset_table_rtx", ")", "return", "orig", ";", "gcc_assert", "(", "reg", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "orig", ",", "0", ")", ")", "==", "PLUS", ")", ";", "base", "=", "legitimize_pic_address", "(", "XEXP", "(", "XEXP", "(", "orig", ",", "0", ")", ",", "0", ")", ",", "Pmode", ",", "reg", ")", ";", "orig", "=", "legitimize_pic_address", "(", "XEXP", "(", "XEXP", "(", "orig", ",", "0", ")", ",", "1", ")", ",", "Pmode", ",", "base", "==", "reg", "?", "0", ":", "reg", ")", ";", "if", "(", "GET_CODE", "(", "orig", ")", "==", "CONST_INT", ")", "return", "plus_constant", "(", "base", ",", "INTVAL", "(", "orig", ")", ")", ";", "pic_ref", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "base", ",", "orig", ")", ";", "}", "return", "pic_ref", ";", "}", "</s>" ]

[ "Legitimize", "PIC", "addresses", ".", "If", "the", "address", "is", "already", "position-independent", ",", "we", "return", "ORIG", ".", "Newly", "generated", "position-independent", "addresses", "go", "into", "a", "reg", ".", "This", "is", "REG", "if", "nonzero", ",", "otherwise", "we", "allocate", "register", "(", "s", ")", "as", "necessary", "." ]

[ "m68k", "1", "1", "0", "0", "0", "0", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "bool", "constant_address_p", "(", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "LABEL_REF", ":", "case", "CONST_INT", ":", "case", "HIGH", ":", "return", "true", ";", "case", "CONST", ":", "if", "(", "flag_pic", "&&", "pic_address_needs_scratch", "(", "x", ")", ")", "return", "false", ";", "return", "legitimate_constant_p", "(", "x", ")", ";", "case", "SYMBOL_REF", ":", "return", "!", "flag_pic", "&&", "legitimate_constant_p", "(", "x", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Determine", "if", "a", "given", "RTX", "is", "a", "valid", "constant", "address", "." ]

[ "sparc" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "STPSUPPRESS_PASS_NAME", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "static", "tree", "sh_handle_interrupt_handler_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "an", "``", "interrupt_handler", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "sh", "\"%qE attribute only applies to functions\"" ]

[]

[ "<s>", "int", "no_side_effect_operand", "(", "rtx", "op", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "addr", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "FALSE", ";", "indirection", ":", "addr", "=", "XEXP", "(", "op", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "return", "1", ";", "case", "PRE_DEC", ":", "case", "POST_INC", ":", "case", "PRE_MODIFY", ":", "case", "POST_MODIFY", ":", "return", "0", ";", "case", "MEM", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "REG", ")", "return", "0", ";", "op", "=", "addr", ";", "goto", "indirection", ";", "case", "CONST_INT", ":", "case", "LABEL_REF", ":", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "return", "0", ";", "case", "PLUS", ":", "return", "0", ";", "default", ":", "break", ";", "}", "return", "FALSE", ";", "}", "</s>" ]

[ "Similar", "to", "simple_memory_operand", "but", "does", "n't", "match", "push/pop", "." ]

[ "pdp11", "0", "1", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "arm_init_expanders", "(", "void", ")", "{", "init_machine_status", "=", "arm_init_machine_status", ";", "if", "(", "cfun", ")", "mark_reg_pointer", "(", "arg_pointer_rtx", ",", "PARM_BOUNDARY", ")", ";", "}", "</s>" ]

[ "Do", "anything", "needed", "before", "RTL", "is", "emitted", "for", "each", "function", "." ]

[ "arm" ]

[]

[ "<s>", "static", "int", "m32r_adjust_priority", "(", "rtx_insn", "*", "insn", ",", "int", "priority", ")", "{", "if", "(", "m32r_is_insn", "(", "insn", ")", "&&", "get_attr_insn_size", "(", "insn", ")", "!=", "INSN_SIZE_SHORT", ")", "priority", "<<=", "3", ";", "return", "priority", ";", "}", "</s>" ]

[ "Increase", "the", "priority", "of", "long", "instructions", "so", "that", "the", "short", "instructions", "are", "scheduled", "ahead", "of", "the", "long", "ones", "." ]

[ "m32r", "3" ]

[]

[ "<s>", "unsigned", "TeakRegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "Teak", "::", "GRRegsRegClassID", ":", "return", "7", ";", "case", "Teak", "::", "SVRegRegClassID", ":", "return", "0", ";", "case", "Teak", "::", "ABRegsRegClassID", ":", "return", "4", ";", "case", "Teak", "::", "ALRegsRegClassID", ":", "return", "2", ";", "case", "Teak", "::", "ABLRegsRegClassID", ":", "return", "4", ";", "case", "Teak", "::", "RegNoBRegs16_nohRegClassID", ":", "return", "12", ";", "case", "Teak", "::", "RegNoBRegs16_noh_pageRegClassID", ":", "return", "12", "+", "80", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "Teak", "Teak", "0", "Teak::GRRegsRegClassID", "7", "Teak::SVRegRegClassID", "0", "Teak::ABRegsRegClassID", "4", "Teak::ALRegsRegClassID", "2", "Teak::ABLRegsRegClassID", "4", "Teak::RegNoBRegs16_nohRegClassID", "12", "Teak::RegNoBRegs16_noh_pageRegClassID", "12", "80" ]

[]

[ "<s>", "bool", "pbsada_insn_rt_dep_reg_p", "(", "rtx", "pbsada_insn", ",", "rtx", "def_reg", ")", "{", "rtx", "pbsada_rt", "=", "SET_DEST", "(", "PATTERN", "(", "pbsada_insn", ")", ")", ";", "if", "(", "rtx_equal_p", "(", "def_reg", ",", "pbsada_rt", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Determine", "if", "the", "latency", "is", "occured", "when", "the", "consumer", "PBSADA_INSN", "uses", "the", "value", "of", "DEF_REG", "in", "its", "Rt", "field", "." ]

[ "nds32" ]

[]

[ "<s>", "static", "void", "epiphany_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "register", "rtx", "base", ",", "index", "=", "0", ";", "int", "offset", "=", "0", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fputs", "(", "reg_names", "[", "REGNO", "(", "addr", ")", "]", ",", "file", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "if", "(", "0", "&&", "SYMBOL_REF_FUNCTION_P", "(", "addr", ")", ")", "{", "output_addr_const", "(", "file", ",", "addr", ")", ";", "}", "else", "{", "output_addr_const", "(", "file", ",", "addr", ")", ";", "}", "break", ";", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "CONST_INT", ")", "offset", "=", "INTVAL", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "CONST_INT", ")", "offset", "=", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "else", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ",", "index", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "base", ")", "==", "REG", ")", ";", "fputs", "(", "reg_names", "[", "REGNO", "(", "base", ")", "]", ",", "file", ")", ";", "if", "(", "index", "==", "0", ")", "{", "fprintf", "(", "file", ",", "\",%s%d\"", ",", "IMMEDIATE_PREFIX", ",", "offset", "/", "current_frame_info", ".", "stld_sz", ")", ";", "}", "else", "{", "switch", "(", "GET_CODE", "(", "index", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "\",%s\"", ",", "reg_names", "[", "REGNO", "(", "index", ")", "]", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "fputc", "(", "','", ",", "file", ")", ",", "output_addr_const", "(", "file", ",", "index", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "break", ";", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "case", "POST_INC", ":", "case", "POST_DEC", ":", "case", "POST_MODIFY", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "default", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>" ]

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

[ "epiphany", "0", "0", "0", "0", "0", "1", "1", "1", "0", "0", "1", "0", "\",%s%d\"", "\",%s\"" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "PPCInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "const", "TargetMachine", "*", "TM", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "const", "TargetInstrInfo", "*", "TII", "=", "TM", "->", "getInstrInfo", "(", ")", ";", "assert", "(", "TII", "&&", "\"No InstrInfo?\"", ")", ";", "return", "new", "PPCHazardRecognizer970", "(", "*", "TII", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "this", "target", "when", "scheduling", "the", "machine", "instructions", "before", "register", "allocation", "." ]

[ "PowerPC", "PPC", "\"No InstrInfo?\"", "PPC" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "SIInstrInfo", "::", "getSerializableDirectMachineOperandTargetFlags", "(", ")", "const", "{", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_GOTPCREL", ",", "\"amdgpu-gotprel\"", "}", ",", "{", "MO_GOTPCREL32_LO", ",", "\"amdgpu-gotprel32-lo\"", "}", ",", "{", "MO_GOTPCREL32_HI", ",", "\"amdgpu-gotprel32-hi\"", "}", ",", "{", "MO_REL32_LO", ",", "\"amdgpu-rel32-lo\"", "}", ",", "{", "MO_REL32_HI", ",", "\"amdgpu-rel32-hi\"", "}", ",", "{", "MO_ABS32_LO", ",", "\"amdgpu-abs32-lo\"", "}", ",", "{", "MO_ABS32_HI", ",", "\"amdgpu-abs32-hi\"", "}", ",", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "\"amdgpu-gotprel\"", "\"amdgpu-gotprel32-lo\"", "\"amdgpu-gotprel32-hi\"", "\"amdgpu-rel32-lo\"", "\"amdgpu-rel32-hi\"", "\"amdgpu-abs32-lo\"", "\"amdgpu-abs32-hi\"" ]

[]

[ "<s>", "static", "void", "register_tuple_type", "(", "unsigned", "int", "num_vectors", ",", "vector_type_index", "type", ")", "{", "tree", "tuple_type", "=", "lang_hooks", ".", "types", ".", "make_type", "(", "RECORD_TYPE", ")", ";", "char", "buffer", "[", "sizeof", "(", "\"svbfloat16x4_t\"", ")", "]", ";", "const", "char", "*", "vector_type_name", "=", "vector_types", "[", "type", "]", ".", "acle_name", ";", "snprintf", "(", "buffer", ",", "sizeof", "(", "buffer", ")", ",", "\"%.*sx%d_t\"", ",", "(", "int", ")", "strlen", "(", "vector_type_name", ")", "-", "2", ",", "vector_type_name", ",", "num_vectors", ")", ";", "tree", "vector_type", "=", "acle_vector_types", "[", "0", "]", "[", "type", "]", ";", "tree", "array_type", "=", "build_array_type_nelts", "(", "vector_type", ",", "num_vectors", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "TYPE_MODE", "(", "array_type", ")", ")", "&&", "TYPE_MODE_RAW", "(", "array_type", ")", "==", "TYPE_MODE", "(", "array_type", ")", "&&", "TYPE_ALIGN", "(", "array_type", ")", "==", "128", ")", ";", "tree", "field", "=", "build_decl", "(", "input_location", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__val\"", ")", ",", "array_type", ")", ";", "DECL_FIELD_CONTEXT", "(", "field", ")", "=", "tuple_type", ";", "TYPE_FIELDS", "(", "tuple_type", ")", "=", "field", ";", "add_sve_type_attribute", "(", "tuple_type", ",", "num_vectors", ",", "0", ",", "NULL", ",", "buffer", ")", ";", "make_type_sizeless", "(", "tuple_type", ")", ";", "layout_type", "(", "tuple_type", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "TYPE_MODE", "(", "tuple_type", ")", ")", "&&", "TYPE_MODE_RAW", "(", "tuple_type", ")", "==", "TYPE_MODE", "(", "tuple_type", ")", "&&", "TYPE_ALIGN", "(", "tuple_type", ")", "==", "128", ")", ";", "tree", "decl", "=", "build_decl", "(", "input_location", ",", "TYPE_DECL", ",", "get_identifier", "(", "buffer", ")", ",", "tuple_type", ")", ";", "TYPE_NAME", "(", "tuple_type", ")", "=", "decl", ";", "TYPE_STUB_DECL", "(", "tuple_type", ")", "=", "decl", ";", "lang_hooks", ".", "decls", ".", "pushdecl", "(", "decl", ")", ";", "DECL_ORIGINAL_TYPE", "(", "decl", ")", "=", "NULL_TREE", ";", "acle_vector_types", "[", "num_vectors", "-", "1", "]", "[", "type", "]", "=", "tuple_type", ";", "}", "</s>" ]

[ "Register", "the", "tuple", "type", "that", "contains", "NUM_VECTORS", "vectors", "of", "type", "TYPE", "." ]

[ "aarch64", "\"svbfloat16x4_t\"", "\"%.*sx%d_t\"", "2", "0", "128", "\"__val\"", "0", "128", "1" ]

[]

[ "<s>", "static", "rtx", "add_constant", "(", "struct", "mips16_constant_pool", "*", "pool", ",", "rtx", "value", ",", "enum", "machine_mode", "mode", ")", "{", "struct", "mips16_constant", "*", "*", "p", ",", "*", "c", ";", "bool", "first_of_size_p", ";", "first_of_size_p", "=", "true", ";", "for", "(", "p", "=", "&", "pool", "->", "first", ";", "*", "p", "!=", "0", ";", "p", "=", "&", "(", "*", "p", ")", "->", "next", ")", "{", "if", "(", "mode", "==", "(", "*", "p", ")", "->", "mode", "&&", "rtx_equal_p", "(", "value", ",", "(", "*", "p", ")", "->", "value", ")", ")", "return", "(", "*", "p", ")", "->", "label", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<", "GET_MODE_SIZE", "(", "(", "*", "p", ")", "->", "mode", ")", ")", "break", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "GET_MODE_SIZE", "(", "(", "*", "p", ")", "->", "mode", ")", ")", "first_of_size_p", "=", "false", ";", "}", "if", "(", "pool", "->", "first", "==", "0", ")", "pool", "->", "highest_address", "=", "pool", "->", "insn_address", "-", "(", "UNITS_PER_WORD", "-", "2", ")", "+", "0x8000", ";", "pool", "->", "highest_address", "-=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "first_of_size_p", ")", "pool", "->", "highest_address", "-=", "GET_MODE_SIZE", "(", "mode", ")", "-", "1", ";", "c", "=", "(", "struct", "mips16_constant", "*", ")", "xmalloc", "(", "sizeof", "*", "c", ")", ";", "c", "->", "value", "=", "value", ";", "c", "->", "mode", "=", "mode", ";", "c", "->", "label", "=", "gen_label_rtx", "(", ")", ";", "c", "->", "next", "=", "*", "p", ";", "*", "p", "=", "c", ";", "return", "c", "->", "label", ";", "}", "</s>" ]

[ "Add", "a", "constant", "to", "the", "pool", "and", "return", "its", "label", "." ]

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

[]

[ "<s>", "unsigned", "int", "arm_dbx_register_number", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "regno", "<", "16", ")", "return", "regno", ";", "if", "(", "IS_VFP_REGNUM", "(", "regno", ")", ")", "{", "if", "(", "VFP_REGNO_OK_FOR_SINGLE", "(", "regno", ")", ")", "return", "64", "+", "regno", "-", "FIRST_VFP_REGNUM", ";", "else", "return", "256", "+", "(", "regno", "-", "FIRST_VFP_REGNUM", ")", "/", "2", ";", "}", "if", "(", "IS_IWMMXT_GR_REGNUM", "(", "regno", ")", ")", "return", "104", "+", "regno", "-", "FIRST_IWMMXT_GR_REGNUM", ";", "if", "(", "IS_IWMMXT_REGNUM", "(", "regno", ")", ")", "return", "112", "+", "regno", "-", "FIRST_IWMMXT_REGNUM", ";", "return", "DWARF_FRAME_REGISTERS", ";", "}", "</s>" ]

[ "Map", "internal", "gcc", "register", "numbers", "to", "DWARF2", "register", "numbers", "." ]

[ "arm", "16", "64", "256", "2", "104", "112" ]

[]

[ "<s>", "int", "short_memory_operand", "(", "rtx", "x", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "!", "memory_operand", "(", "x", ",", "mode", ")", ")", "return", "0", ";", "return", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "!=", "PLUS", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "OP", "is", "a", "valid", "operand", "for", "a", "`", "short", "'", "memory", "reference", "insn", "." ]

[ "stormy16", "0", "0" ]

[]

[ "<s>", "int", "addr24_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "sym", ";", "if", "(", "flag_pic", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "LABEL_REF", ")", "return", "TARGET_ADDR24", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", ")", "sym", "=", "op", ";", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", "&&", "UINT24_P", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", ")", ")", "sym", "=", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ";", "else", "return", "0", ";", "if", "(", "SYMBOL_REF_MODEL", "(", "sym", ")", "==", "M32R_MODEL_SMALL", ")", "return", "1", ";", "if", "(", "TARGET_ADDR24", "&&", "(", "CONSTANT_POOL_ADDRESS_P", "(", "sym", ")", "||", "LIT_NAME_P", "(", "XSTR", "(", "sym", ",", "0", ")", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "OP", "is", "a", "symbol", "that", "can", "use", "24", "bit", "addressing", "." ]

[ "m32r", "0", "0", "0", "0", "0", "1", "0", "1", "0", "0", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "&", "MI", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred", ")", "const", "{", "assert", "(", "Pred", ".", "size", "(", ")", "==", "2", "&&", "\"Invalid condition\"", ")", ";", "unsigned", "CCValid", "=", "Pred", "[", "0", "]", ".", "getImm", "(", ")", ";", "unsigned", "CCMask", "=", "Pred", "[", "1", "]", ".", "getImm", "(", ")", ";", "assert", "(", "CCMask", ">", "0", "&&", "CCMask", "<", "15", "&&", "\"Invalid predicate\"", ")", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "STI", ".", "hasLoadStoreOnCond", "(", ")", ")", "{", "if", "(", "unsigned", "CondOpcode", "=", "getConditionalMove", "(", "Opcode", ")", ")", "{", "MI", ".", "setDesc", "(", "get", "(", "CondOpcode", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "addReg", "(", "SystemZ", "::", "CC", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "}", "if", "(", "Opcode", "==", "SystemZ", "::", "Return", ")", "{", "MI", ".", "setDesc", "(", "get", "(", "SystemZ", "::", "CondReturn", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "addReg", "(", "SystemZ", "::", "CC", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "if", "(", "Opcode", "==", "SystemZ", "::", "CallJG", ")", "{", "const", "GlobalValue", "*", "Global", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getGlobal", "(", ")", ";", "const", "uint32_t", "*", "RegMask", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getRegMask", "(", ")", ";", "MI", ".", "RemoveOperand", "(", "1", ")", ";", "MI", ".", "RemoveOperand", "(", "0", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "SystemZ", "::", "CallBRCL", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "addGlobalAddress", "(", "Global", ")", ".", "addRegMask", "(", "RegMask", ")", ".", "addReg", "(", "SystemZ", "::", "CC", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "if", "(", "Opcode", "==", "SystemZ", "::", "CallBR", ")", "{", "const", "uint32_t", "*", "RegMask", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getRegMask", "(", ")", ";", "MI", ".", "RemoveOperand", "(", "0", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "SystemZ", "::", "CallBCR", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "addRegMask", "(", "RegMask", ")", ".", "addReg", "(", "SystemZ", "::", "CC", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Convert", "the", "instruction", "into", "a", "predicated", "instruction", "." ]

[ "SystemZ", "SystemZ", "2", "\"Invalid condition\"", "0", "1", "0", "15", "\"Invalid predicate\"", "SystemZ::CC", "SystemZ::Return", "SystemZ::CondReturn", "SystemZ::CC", "SystemZ::CallJG", "0", "1", "1", "0", "SystemZ::CallBRCL", "SystemZ::CC", "SystemZ::CallBR", "0", "0", "SystemZ::CallBCR", "SystemZ::CC" ]

[]

[ "<s>", "void", "AAPTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "FLT_ROUNDS_", ":", "Results", ".", "push_back", "(", "DAG", ".", "getTargetConstant", "(", "-", "1", ",", "SDLoc", "(", "N", ")", ",", "MVT", "::", "i32", ")", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unhandled node in ReplaceNodeResults\"", ")", ";", "}", "}", "</s>" ]

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

[ "AAP", "AAP", "ISD::FLT_ROUNDS_", "1", "MVT::i32", "\"Unhandled node in ReplaceNodeResults\"" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "bool", "MSP430InstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "break", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "return", "true", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "MSP430", "::", "Br", "||", "I", "->", "getOpcode", "(", ")", "==", "MSP430", "::", "Bm", ")", "return", "true", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "MSP430", "::", "JMP", ")", "{", "if", "(", "!", "AllowModify", ")", "{", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "while", "(", "std", "::", "next", "(", "I", ")", "!=", "MBB", ".", "end", "(", ")", ")", "std", "::", "next", "(", "I", ")", "->", "eraseFromParent", "(", ")", ";", "Cond", ".", "clear", "(", ")", ";", "FBB", "=", "nullptr", ";", "if", "(", "MBB", ".", "isLayoutSuccessor", "(", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ")", "{", "TBB", "=", "nullptr", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "continue", ";", "}", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "assert", "(", "I", "->", "getOpcode", "(", ")", "==", "MSP430", "::", "JCC", "&&", "\"Invalid conditional branch\"", ")", ";", "MSP430CC", "::", "CondCodes", "BranchCode", "=", "static_cast", "<", "MSP430CC", "::", "CondCodes", ">", "(", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", ";", "if", "(", "BranchCode", "==", "MSP430CC", "::", "COND_INVALID", ")", "return", "true", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "FBB", "=", "TBB", ";", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "BranchCode", ")", ")", ";", "continue", ";", "}", "assert", "(", "Cond", ".", "size", "(", ")", "==", "1", ")", ";", "assert", "(", "TBB", ")", ";", "if", "(", "TBB", "!=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", "return", "true", ";", "MSP430CC", "::", "CondCodes", "OldBranchCode", "=", "(", "MSP430CC", "::", "CondCodes", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "if", "(", "OldBranchCode", "==", "BranchCode", ")", "continue", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "MSP430", "MSP430", "MSP430::Br", "MSP430::Bm", "MSP430::JMP", "0", "0", "0", "MSP430::JCC", "\"Invalid conditional branch\"", "MSP430CC::CondCodes", "MSP430CC::CondCodes", "1", "MSP430CC::COND_INVALID", "0", "1", "0", "MSP430CC::CondCodes", "MSP430CC::CondCodes", "0" ]

[]

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "EXEC", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "FLAT_SCR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "M0", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_SHARED_BASE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_SHARED_LIMIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_PRIVATE_BASE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_PRIVATE_LIMIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_POPS_EXITING_WAVE_ID", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "XNACK_MASK", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "LDS_DIRECT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TBA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TMA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP0_TTMP1", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP2_TTMP3", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP4_TTMP5", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP6_TTMP7", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP8_TTMP9", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP10_TTMP11", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP12_TTMP13", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP14_TTMP15", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "unsigned", "MaxNumSGPRs", "=", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumSGPRs", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumSGPRs", ";", "i", "<", "TotalNumSGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "unsigned", "MaxNumVGPRs", "=", "ST", ".", "getMaxNumVGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumVGPRs", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumVGPRs", ";", "i", "<", "TotalNumVGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "ScratchWaveOffsetReg", "=", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ";", "if", "(", "ScratchWaveOffsetReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchWaveOffsetReg", ")", ";", "}", "unsigned", "ScratchRSrcReg", "=", "MFI", "->", "getScratchRSrcReg", "(", ")", ";", "if", "(", "ScratchRSrcReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchRSrcReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "ScratchWaveOffsetReg", ")", ")", ";", "}", "unsigned", "StackPtrReg", "=", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ";", "if", "(", "StackPtrReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "StackPtrReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "StackPtrReg", ")", ")", ";", "}", "unsigned", "FrameReg", "=", "MFI", "->", "getFrameOffsetReg", "(", ")", ";", "if", "(", "FrameReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "FrameReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "FrameReg", ")", ")", ";", "}", "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", "." ]

[ "AMDGPU", "SI", "AMDGPU::EXEC", "AMDGPU::FLAT_SCR", "AMDGPU::M0", "AMDGPU::SRC_SHARED_BASE", "AMDGPU::SRC_SHARED_LIMIT", "AMDGPU::SRC_PRIVATE_BASE", "AMDGPU::SRC_PRIVATE_LIMIT", "AMDGPU::SRC_POPS_EXITING_WAVE_ID", "AMDGPU::XNACK_MASK", "AMDGPU::LDS_DIRECT", "AMDGPU::TBA", "AMDGPU::TMA", "AMDGPU::TTMP0_TTMP1", "AMDGPU::TTMP2_TTMP3", "AMDGPU::TTMP4_TTMP5", "AMDGPU::TTMP6_TTMP7", "AMDGPU::TTMP8_TTMP9", "AMDGPU::TTMP10_TTMP11", "AMDGPU::TTMP12_TTMP13", "AMDGPU::TTMP14_TTMP15", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "SI", "SI", "AMDGPU::NoRegister", "AMDGPU::NoRegister", "AMDGPU::NoRegister", "AMDGPU::NoRegister" ]

[]

[ "<s>", "MachineBasicBlock", "*", "RISCVTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "RISCV", "::", "Select_GPR_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_FPR32_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_FPR64_Using_CC_GPR", ":", "break", ";", "case", "RISCV", "::", "BuildPairF64Pseudo", ":", "return", "emitBuildPairF64Pseudo", "(", "MI", ",", "BB", ")", ";", "case", "RISCV", "::", "SplitF64Pseudo", ":", "return", "emitSplitF64Pseudo", "(", "MI", ",", "BB", ")", ";", "}", "const", "TargetInstrInfo", "&", "TII", "=", "*", "BB", "->", "getParent", "(", ")", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "MachineFunction", "::", "iterator", "I", "=", "++", "BB", "->", "getIterator", "(", ")", ";", "MachineBasicBlock", "*", "HeadMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "TailMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "IfFalseMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "I", ",", "IfFalseMBB", ")", ";", "F", "->", "insert", "(", "I", ",", "TailMBB", ")", ";", "TailMBB", "->", "splice", "(", "TailMBB", "->", "begin", "(", ")", ",", "HeadMBB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "HeadMBB", "->", "end", "(", ")", ")", ";", "TailMBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "HeadMBB", ")", ";", "HeadMBB", "->", "addSuccessor", "(", "IfFalseMBB", ")", ";", "HeadMBB", "->", "addSuccessor", "(", "TailMBB", ")", ";", "unsigned", "LHS", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "unsigned", "RHS", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "auto", "CC", "=", "static_cast", "<", "ISD", "::", "CondCode", ">", "(", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ")", ";", "unsigned", "Opcode", "=", "getBranchOpcodeForIntCondCode", "(", "CC", ")", ";", "BuildMI", "(", "HeadMBB", ",", "DL", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "LHS", ")", ".", "addReg", "(", "RHS", ")", ".", "addMBB", "(", "TailMBB", ")", ";", "IfFalseMBB", "->", "addSuccessor", "(", "TailMBB", ")", ";", "BuildMI", "(", "*", "TailMBB", ",", "TailMBB", "->", "begin", "(", ")", ",", "DL", ",", "TII", ".", "get", "(", "RISCV", "::", "PHI", ")", ",", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "4", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "HeadMBB", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "5", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "IfFalseMBB", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "return", "TailMBB", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"Unexpected instr type to insert\"", "RISCV::Select_GPR_Using_CC_GPR", "RISCV::Select_FPR32_Using_CC_GPR", "RISCV::Select_FPR64_Using_CC_GPR", "RISCV::BuildPairF64Pseudo", "RISCV::SplitF64Pseudo", "1", "2", "ISD::CondCode", "3", "RISCV::PHI", "0", "4", "5" ]

[]

[ "<s>", "bool", "OptimizeLEAPass", "::", "isReplaceable", "(", "const", "MachineInstr", "&", "First", ",", "const", "MachineInstr", "&", "Last", ",", "int64_t", "&", "AddrDispShift", ")", "{", "assert", "(", "isLEA", "(", "First", ")", "&&", "isLEA", "(", "Last", ")", "&&", "\"The function works only with LEA instructions\"", ")", ";", "if", "(", "!", "isSimilarMemOp", "(", "Last", ",", "1", ",", "First", ",", "1", ",", "AddrDispShift", ")", ")", "return", "false", ";", "if", "(", "MRI", "->", "getRegClass", "(", "First", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "!=", "MRI", "->", "getRegClass", "(", "Last", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "return", "false", ";", "for", "(", "auto", "&", "MO", ":", "MRI", "->", "use_operands", "(", "Last", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MO", ".", "getParent", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MI", ".", "getDesc", "(", ")", ";", "int", "MemOpNo", "=", "X86II", "::", "getMemoryOperandNo", "(", "Desc", ".", "TSFlags", ",", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "MemOpNo", "<", "0", ")", "return", "false", ";", "MemOpNo", "+=", "X86II", "::", "getOperandBias", "(", "Desc", ")", ";", "if", "(", "!", "isIdenticalOp", "(", "MI", ".", "getOperand", "(", "MemOpNo", "+", "X86", "::", "AddrBaseReg", ")", ",", "MO", ")", ")", "return", "false", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MI", ".", "getNumOperands", "(", ")", ";", "i", "++", ")", "if", "(", "i", "!=", "(", "unsigned", ")", "(", "MemOpNo", "+", "X86", "::", "AddrBaseReg", ")", "&&", "isIdenticalOp", "(", "MI", ".", "getOperand", "(", "i", ")", ",", "MO", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "getOperand", "(", "MemOpNo", "+", "X86", "::", "AddrDisp", ")", ".", "isImm", "(", ")", "&&", "!", "isInt", "<", "32", ">", "(", "MI", ".", "getOperand", "(", "MemOpNo", "+", "X86", "::", "AddrDisp", ")", ".", "getImm", "(", ")", "+", "AddrDispShift", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Check", "whether", "metadata", "is", "replaceable", "." ]

[ "X86", "\"The function works only with LEA instructions\"", "1", "1", "0", "0", "0", "X86II::getMemoryOperandNo", "0", "X86II::getOperandBias", "X86::AddrBaseReg", "0", "X86::AddrBaseReg", "X86::AddrDisp", "32", "X86::AddrDisp" ]

[]

[ "<s>", "const", "MCSection", "*", "PIC16TargetObjectFile", "::", "getExplicitSectionGlobal", "(", "const", "GlobalValue", "*", "GV", ",", "SectionKind", "Kind", ",", "Mangler", "*", "Mang", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "assert", "(", "GV", "->", "hasSection", "(", ")", ")", ";", "if", "(", "const", "GlobalVariable", "*", "GVar", "=", "cast", "<", "GlobalVariable", ">", "(", "GV", ")", ")", "{", "std", "::", "string", "SectName", "=", "GVar", "->", "getSection", "(", ")", ";", "std", "::", "string", "AddrStr", "=", "\"Address=\"", ";", "if", "(", "SectName", ".", "compare", "(", "0", ",", "AddrStr", ".", "length", "(", ")", ",", "AddrStr", ")", "==", "0", ")", "{", "std", "::", "string", "SectAddr", "=", "SectName", ".", "substr", "(", "AddrStr", ".", "length", "(", ")", ")", ";", "return", "CreateSectionForGlobal", "(", "GVar", ",", "Mang", ",", "SectAddr", ")", ";", "}", "return", "CreateSectionForGlobal", "(", "GVar", ",", "Mang", ")", ";", "}", "return", "getPIC16Section", "(", "GV", "->", "getSection", "(", ")", ".", "c_str", "(", ")", ",", "Kind", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "method", "to", "assign", "a", "section", "to", "globals", "with", "an", "explicit", "section", "specfied", "." ]

[ "PIC16", "PIC16", "\"Address=\"", "0", "0", "PIC16" ]

[]

[ "<s>", "mips_output_ascii", "(", "STREAM", ",", "STRING", ",", "LEN", ")", "{", "\\", "const", "char", "*", "p", "=", "STRING", ";", "\\", "int", "size", "=", "strlen", "(", "p", ")", "+", "1", ";", "\\", "rdata_section", "(", ")", ";", "\\", "assemble_string", "(", "p", ",", "size", ")", ";", "\\", "}", "</s>" ]

[ "Output", "an", "ASCII", "string", ",", "in", "a", "space-saving", "way", ".", "PREFIX", "is", "the", "string", "that", "should", "be", "written", "before", "the", "opening", "quote", ",", "such", "as", "``", "\\t.ascii\\t", "''", "for", "real", "string", "data", "or", "``", "\\t", "#", "``", "for", "a", "comment", "." ]

[ "mips", "1" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "PPCTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'b'", ":", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "PPC", "::", "G8RCRegisterClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "PPC", "::", "GPRCRegisterClass", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "PPC", "::", "F4RCRegisterClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "PPC", "::", "F8RCRegisterClass", ")", ";", "break", ";", "case", "'v'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "PPC", "::", "VRRCRegisterClass", ")", ";", "case", "'y'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "PPC", "::", "CRRCRegisterClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "1", "0", "MVT::i64", "PPC", "PPC", "0U", "PPC::G8RCRegisterClass", "0U", "PPC::GPRCRegisterClass", "MVT::f32", "0U", "PPC::F4RCRegisterClass", "MVT::f64", "0U", "PPC::F8RCRegisterClass", "0U", "PPC::VRRCRegisterClass", "0U", "PPC::CRRCRegisterClass" ]

[]

[ "<s>", "static", "bool", "xtensa_legitimate_constant_p", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "return", "!", "xtensa_tls_referenced_p", "(", "x", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_CONSTANT_P", "." ]

[ "xtensa" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "SIRegisterInfo", "::", "getRegClass", "(", "unsigned", "RCID", ")", "const", "{", "switch", "(", "(", "int", ")", "RCID", ")", "{", "case", "AMDGPU", "::", "SReg_1RegClassID", ":", "return", "getBoolRC", "(", ")", ";", "case", "AMDGPU", "::", "SReg_1_XEXECRegClassID", ":", "return", "isWave32", "?", "&", "AMDGPU", "::", "SReg_32_XM0_XEXECRegClass", ":", "&", "AMDGPU", "::", "SReg_64_XEXECRegClass", ";", "case", "-", "1", ":", "return", "nullptr", ";", "default", ":", "return", "AMDGPURegisterInfo", "::", "getRegClass", "(", "RCID", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::SReg_1RegClassID", "AMDGPU::SReg_1_XEXECRegClassID", "AMDGPU::SReg_32_XM0_XEXECRegClass", "AMDGPU::SReg_64_XEXECRegClass", "1", "AMDGPU" ]

[]

[ "<s>", "enum", "reg_class", "secondary_reload_class", "(", "enum", "reg_class", "class", ",", "enum", "machine_mode", "mode", ",", "rtx", "x", ",", "int", "in", ")", "{", "if", "(", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "&&", "!", "TARGET_BWX", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", "||", "(", "GET_CODE", "(", "x", ")", "==", "REG", "&&", "REGNO", "(", "x", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", "||", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "(", "GET_CODE", "(", "SUBREG_REG", "(", "x", ")", ")", "==", "MEM", "||", "(", "GET_CODE", "(", "SUBREG_REG", "(", "x", ")", ")", "==", "REG", "&&", "REGNO", "(", "SUBREG_REG", "(", "x", ")", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", ")", ")", ")", "{", "if", "(", "!", "in", "||", "!", "aligned_memory_operand", "(", "x", ",", "mode", ")", ")", "return", "GENERAL_REGS", ";", "}", "}", "if", "(", "class", "==", "FLOAT_REGS", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "AND", ")", "return", "GENERAL_REGS", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ">", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ")", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "in", "&&", "INTEGRAL_MODE_P", "(", "mode", ")", "&&", "!", "(", "memory_operand", "(", "x", ",", "mode", ")", "||", "x", "==", "const0_rtx", ")", ")", "return", "GENERAL_REGS", ";", "}", "</s>" ]

[ "Return", "the", "class", "of", "any", "secondary", "reload", "register", "that", "is", "needed", "to", "move", "IN", "into", "a", "register", "in", "class", "CLASS", "using", "mode", "MODE", ".", "Profiling", "has", "showed", "this", "routine", "and", "its", "descendants", "account", "for", "a", "significant", "amount", "of", "compile", "time", "(", "~7", "%", ")", ".", "So", "it", "has", "been", "optimized", "to", "reduce", "redundant", "computations", "and", "eliminate", "useless", "function", "calls", ".", "It", "might", "be", "worthwhile", "to", "try", "and", "make", "this", "a", "leaf", "function", "too", "." ]

[ "alpha", "0" ]

[]

[ "<s>", "void", "AArch64FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "AArch64InstrInfo", "*", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "int", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "IsDestroy", "=", "Opc", "==", "TII", "->", "getCallFrameDestroyOpcode", "(", ")", ";", "uint64_t", "CalleePopAmount", "=", "IsDestroy", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "unsigned", "Align", "=", "getStackAlignment", "(", ")", ";", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "Amount", "=", "RoundUpToAlignment", "(", "Amount", ",", "Align", ")", ";", "if", "(", "!", "IsDestroy", ")", "Amount", "=", "-", "Amount", ";", "if", "(", "CalleePopAmount", "==", "0", ")", "{", "assert", "(", "Amount", ">", "-", "0xffffff", "&&", "Amount", "<", "0xffffff", "&&", "\"call frame too large\"", ")", ";", "emitFrameOffset", "(", "MBB", ",", "I", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "SP", ",", "Amount", ",", "TII", ")", ";", "}", "}", "else", "if", "(", "CalleePopAmount", "!=", "0", ")", "{", "assert", "(", "CalleePopAmount", "<", "0xffffff", "&&", "\"call frame too large\"", ")", ";", "emitFrameOffset", "(", "MBB", ",", "I", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "SP", ",", "-", "CalleePopAmount", ",", "TII", ")", ";", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "1", "0", "0", "0", "0xffffff", "0xffffff", "\"call frame too large\"", "AArch64::SP", "AArch64::SP", "0", "0xffffff", "\"call frame too large\"", "AArch64::SP", "AArch64::SP" ]

[]

[ "<s>", "void", "WebAssemblyTargetWasmStreamer", "::", "emitIndIdx", "(", "const", "MCExpr", "*", "Value", ")", "{", "llvm_unreachable", "(", "\".indidx encoding not yet implemented\"", ")", ";", "}", "</s>" ]

[ ".indidx" ]

[ "WebAssembly", "WebAssembly", "\".indidx encoding not yet implemented\"" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "getMemOperandWithOffset", "(", "const", "MachineInstr", "&", "LdSt", ",", "const", "MachineOperand", "*", "&", "BaseOp", ",", "int64_t", "&", "Offset", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "unsigned", "AccessSize", "=", "0", ";", "BaseOp", "=", "getBaseAndOffset", "(", "LdSt", ",", "Offset", ",", "AccessSize", ")", ";", "return", "BaseOp", "!=", "nullptr", "&&", "BaseOp", "->", "isReg", "(", ")", ";", "}", "</s>" ]

[ "Get", "the", "base", "operand", "and", "byte", "offset", "of", "an", "instruction", "that", "reads/writes", "memory", "." ]

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

[]

[ "<s>", "bool", "isMicroMips", "(", ")", "const", "{", "return", "STI", ".", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureMicroMips", ";", "}", "</s>" ]

[ "Check", "whether", "a", "given", "symbol", "has", "been", "flagged", "with", "MICROMIPS", "flag", "." ]

[ "Mips", "Mips", "Mips::FeatureMicroMips" ]

[]

[ "<s>", "static", "bool", "thumb_force_lr_save", "(", "void", ")", "{", "return", "!", "cfun", "->", "machine", "->", "lr_save_eliminated", "&&", "(", "!", "leaf_function_p", "(", ")", "||", "thumb_far_jump_used_p", "(", ")", "||", "df_regs_ever_live_p", "(", "LR_REGNUM", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "current", "function", "needs", "to", "save/restore", "LR", "." ]

[ "arm" ]

[]

[ "<s>", "static", "rtx", "rx_function_arg", "(", "cumulative_args_t", "cum", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "unsigned", "int", "next_reg", ";", "unsigned", "int", "bytes_so_far", "=", "*", "get_cumulative_args", "(", "cum", ")", ";", "unsigned", "int", "size", ";", "unsigned", "int", "rounded_size", ";", "size", "=", "(", "mode", "==", "BLKmode", ")", "?", "int_size_in_bytes", "(", "type", ")", ":", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "size", "<", "1", ")", "return", "NULL_RTX", ";", "rounded_size", "=", "rx_round_up", "(", "size", ",", "UNITS_PER_WORD", ")", ";", "if", "(", "rounded_size", "+", "bytes_so_far", ">", "MAX_NUM_ARG_BYTES", ")", "return", "NULL_RTX", ";", "if", "(", "!", "named", ")", "return", "NULL_RTX", ";", "if", "(", "(", "type", "==", "NULL", "||", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "&&", "(", "size", "%", "UNITS_PER_WORD", ")", "!=", "0", ")", "return", "NULL_RTX", ";", "next_reg", "=", "(", "bytes_so_far", "/", "UNITS_PER_WORD", ")", "+", "1", ";", "return", "gen_rtx_REG", "(", "mode", ",", "next_reg", ")", ";", "}", "</s>" ]

[ "Return", "an", "RTL", "expression", "describing", "the", "register", "holding", "a", "function", "parameter", "of", "mode", "MODE", "and", "type", "TYPE", "or", "NULL_RTX", "if", "the", "parameter", "should", "be", "passed", "on", "the", "stack", ".", "CUM", "describes", "the", "previous", "parameters", "to", "the", "function", "and", "NAMED", "is", "false", "if", "the", "parameter", "is", "part", "of", "a", "variable", "parameter", "list", ",", "or", "the", "last", "named", "parameter", "before", "the", "start", "of", "a", "variable", "parameter", "list", "." ]

[ "rx", "1", "0", "1" ]

[]

[ "<s>", "void", "AGCDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", "<<", "Node", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "switch", "(", "Node", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "Constant", ":", "{", "SelectAGCConstant", "(", "Node", ")", ";", "return", ";", "}", "}", "for", "(", "auto", "&", "Op", ":", "Node", "->", "ops", "(", ")", ")", "{", "switch", "(", "Op", ".", "getNode", "(", ")", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "Constant", ":", "{", "SelectAGCConstant", "(", "Op", ".", "getNode", "(", ")", ")", ";", "break", ";", "}", "}", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "AGC", "AGC", "\"== \"", "\"\\n\"", "1", "ISD::Constant", "AGC", "ISD::Constant", "AGC" ]

[]

[ "<s>", "static", "void", "ia64_output_function_prologue", "(", "FILE", "*", "file", ")", "{", "int", "mask", ",", "grsave", ",", "grsave_prev", ";", "if", "(", "current_frame_info", ".", "need_regstk", ")", "fprintf", "(", "file", ",", "\"\\t.regstk %d, %d, %d, %d\\n\"", ",", "current_frame_info", ".", "n_input_regs", ",", "current_frame_info", ".", "n_local_regs", ",", "current_frame_info", ".", "n_output_regs", ",", "current_frame_info", ".", "n_rotate_regs", ")", ";", "if", "(", "ia64_except_unwind_info", "(", "&", "global_options", ")", "!=", "UI_TARGET", ")", "return", ";", "mask", "=", "0", ";", "grsave", "=", "grsave_prev", "=", "0", ";", "if", "(", "current_frame_info", ".", "r", "[", "reg_save_b0", "]", "!=", "0", ")", "{", "mask", "|=", "8", ";", "grsave", "=", "grsave_prev", "=", "current_frame_info", ".", "r", "[", "reg_save_b0", "]", ";", "}", "if", "(", "current_frame_info", ".", "r", "[", "reg_save_ar_pfs", "]", "!=", "0", "&&", "(", "grsave_prev", "==", "0", "||", "current_frame_info", ".", "r", "[", "reg_save_ar_pfs", "]", "==", "grsave_prev", "+", "1", ")", ")", "{", "mask", "|=", "4", ";", "if", "(", "grsave_prev", "==", "0", ")", "grsave", "=", "current_frame_info", ".", "r", "[", "reg_save_ar_pfs", "]", ";", "grsave_prev", "=", "current_frame_info", ".", "r", "[", "reg_save_ar_pfs", "]", ";", "}", "if", "(", "current_frame_info", ".", "r", "[", "reg_fp", "]", "!=", "0", "&&", "(", "grsave_prev", "==", "0", "||", "current_frame_info", ".", "r", "[", "reg_fp", "]", "==", "grsave_prev", "+", "1", ")", ")", "{", "mask", "|=", "2", ";", "if", "(", "grsave_prev", "==", "0", ")", "grsave", "=", "HARD_FRAME_POINTER_REGNUM", ";", "grsave_prev", "=", "current_frame_info", ".", "r", "[", "reg_fp", "]", ";", "}", "if", "(", "current_frame_info", ".", "r", "[", "reg_save_pr", "]", "!=", "0", "&&", "(", "grsave_prev", "==", "0", "||", "current_frame_info", ".", "r", "[", "reg_save_pr", "]", "==", "grsave_prev", "+", "1", ")", ")", "{", "mask", "|=", "1", ";", "if", "(", "grsave_prev", "==", "0", ")", "grsave", "=", "current_frame_info", ".", "r", "[", "reg_save_pr", "]", ";", "}", "if", "(", "mask", "&&", "TARGET_GNU_AS", ")", "fprintf", "(", "file", ",", "\"\\t.prologue %d, %d\\n\"", ",", "mask", ",", "ia64_debugger_regno", "(", "grsave", ")", ")", ";", "else", "fputs", "(", "\"\\t.prologue\\n\"", ",", "file", ")", ";", "if", "(", "current_frame_info", ".", "spill_cfa_off", "!=", "-", "16", ")", "fprintf", "(", "file", ",", "\"\\t.spill %ld\\n\"", ",", "(", "long", ")", "(", "current_frame_info", ".", "spill_cfa_off", "+", "current_frame_info", ".", "spill_size", ")", ")", ";", "}", "</s>" ]

[ "Emit", "the", "function", "prologue", "." ]

[ "ia64", "\"\\t.regstk %d, %d, %d, %d\\n\"", "0", "0", "0", "8", "0", "0", "1", "4", "0", "0", "0", "1", "2", "0", "0", "0", "1", "1", "0", "\"\\t.prologue %d, %d\\n\"", "\"\\t.prologue\\n\"", "16", "\"\\t.spill %ld\\n\"" ]

[]

[ "<s>", "SMLoc", "getStartLoc", "(", ")", "const", "override", "{", "return", "StartLoc", ";", "}", "</s>" ]

[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]

[ "DLX" ]

[]

[ "<s>", "bool", "X86FastISel", "::", "fastSelectInstruction", "(", "const", "Instruction", "*", "I", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Instruction", "::", "Load", ":", "return", "X86SelectLoad", "(", "I", ")", ";", "case", "Instruction", "::", "Store", ":", "return", "X86SelectStore", "(", "I", ")", ";", "case", "Instruction", "::", "Ret", ":", "return", "X86SelectRet", "(", "I", ")", ";", "case", "Instruction", "::", "ICmp", ":", "case", "Instruction", "::", "FCmp", ":", "return", "X86SelectCmp", "(", "I", ")", ";", "case", "Instruction", "::", "ZExt", ":", "return", "X86SelectZExt", "(", "I", ")", ";", "case", "Instruction", "::", "Br", ":", "return", "X86SelectBranch", "(", "I", ")", ";", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "case", "Instruction", "::", "Shl", ":", "return", "X86SelectShift", "(", "I", ")", ";", "case", "Instruction", "::", "SDiv", ":", "case", "Instruction", "::", "UDiv", ":", "case", "Instruction", "::", "SRem", ":", "case", "Instruction", "::", "URem", ":", "return", "X86SelectDivRem", "(", "I", ")", ";", "case", "Instruction", "::", "Select", ":", "return", "X86SelectSelect", "(", "I", ")", ";", "case", "Instruction", "::", "Trunc", ":", "return", "X86SelectTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "FPExt", ":", "return", "X86SelectFPExt", "(", "I", ")", ";", "case", "Instruction", "::", "FPTrunc", ":", "return", "X86SelectFPTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "SIToFP", ":", "return", "X86SelectSIToFP", "(", "I", ")", ";", "case", "Instruction", "::", "IntToPtr", ":", "case", "Instruction", "::", "PtrToInt", ":", "{", "EVT", "SrcVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "I", "->", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ";", "EVT", "DstVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "I", "->", "getType", "(", ")", ")", ";", "if", "(", "DstVT", ".", "bitsGT", "(", "SrcVT", ")", ")", "return", "X86SelectZExt", "(", "I", ")", ";", "if", "(", "DstVT", ".", "bitsLT", "(", "SrcVT", ")", ")", "return", "X86SelectTrunc", "(", "I", ")", ";", "unsigned", "Reg", "=", "getRegForValue", "(", "I", "->", "getOperand", "(", "0", ")", ")", ";", "if", "(", "Reg", "==", "0", ")", "return", "false", ";", "updateValueMap", "(", "I", ",", "Reg", ")", ";", "return", "true", ";", "}", "case", "Instruction", "::", "BitCast", ":", "{", "if", "(", "!", "Subtarget", "->", "hasSSE2", "(", ")", ")", "return", "false", ";", "EVT", "SrcVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "I", "->", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ";", "EVT", "DstVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "I", "->", "getType", "(", ")", ")", ";", "if", "(", "!", "SrcVT", ".", "isSimple", "(", ")", "||", "!", "DstVT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "if", "(", "!", "SrcVT", ".", "is128BitVector", "(", ")", "&&", "!", "(", "Subtarget", "->", "hasAVX", "(", ")", "&&", "SrcVT", ".", "is256BitVector", "(", ")", ")", ")", "return", "false", ";", "unsigned", "Reg", "=", "getRegForValue", "(", "I", "->", "getOperand", "(", "0", ")", ")", ";", "if", "(", "Reg", "==", "0", ")", "return", "false", ";", "updateValueMap", "(", "I", ",", "Reg", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "when", "the", "normal", "FastISel", "process", "fails", "to", "select", "an", "instruction", "." ]

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

[]

[ "<s>", "static", "void", "rs6000_parse_abi_options", "(", ")", "{", "if", "(", "rs6000_abi_string", "==", "0", ")", "return", ";", "else", "if", "(", "!", "strcmp", "(", "rs6000_abi_string", ",", "\"altivec\"", ")", ")", "rs6000_altivec_abi", "=", "1", ";", "else", "if", "(", "!", "strcmp", "(", "rs6000_abi_string", ",", "\"no-altivec\"", ")", ")", "rs6000_altivec_abi", "=", "0", ";", "else", "error", "(", "\"unknown ABI specified: '%s'\"", ",", "rs6000_abi_string", ")", ";", "}", "</s>" ]

[ "Handle", "-mabi=", "options", "." ]

[ "rs6000", "0", "\"altivec\"", "1", "\"no-altivec\"", "0", "\"unknown ABI specified: '%s'\"" ]

[]

[ "<s>", "bool", "XCoreInstrInfo", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "bool", "AtStart", "=", "MI", "==", "MBB", ".", "begin", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "BeforeI", "=", "MI", ";", "if", "(", "!", "AtStart", ")", "--", "BeforeI", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "it", "=", "CSI", ".", "begin", "(", ")", ";", "it", "!=", "CSI", ".", "end", "(", ")", ";", "++", "it", ")", "{", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "it", "->", "getReg", "(", ")", ",", "it", "->", "getFrameIdx", "(", ")", ",", "it", "->", "getRegClass", "(", ")", ")", ";", "assert", "(", "MI", "!=", "MBB", ".", "begin", "(", ")", "&&", "\"loadRegFromStackSlot didn't insert any code!\"", ")", ";", "if", "(", "AtStart", ")", "MI", "=", "MBB", ".", "begin", "(", ")", ";", "else", "{", "MI", "=", "BeforeI", ";", "++", "MI", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "\"loadRegFromStackSlot didn't insert any code!\"" ]

[]

[ "<s>", "bool", "umips_movep_target_p", "(", "rtx", "reg1", ",", "rtx", "reg2", ")", "{", "int", "regno1", ",", "regno2", ",", "pair", ";", "unsigned", "int", "i", ";", "static", "const", "int", "match", "[", "8", "]", "=", "{", "0x00000060", ",", "0x000000a0", ",", "0x000000c0", ",", "0x00200010", ",", "0x00400010", ",", "0x00000030", ",", "0x00000050", ",", "0x00000090", "}", ";", "if", "(", "!", "REG_P", "(", "reg1", ")", "||", "!", "REG_P", "(", "reg2", ")", ")", "return", "false", ";", "regno1", "=", "REGNO", "(", "reg1", ")", ";", "regno2", "=", "REGNO", "(", "reg2", ")", ";", "if", "(", "!", "GP_REG_P", "(", "regno1", ")", "||", "!", "GP_REG_P", "(", "regno2", ")", ")", "return", "false", ";", "pair", "=", "(", "1", "<<", "regno1", ")", "|", "(", "1", "<<", "regno2", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "match", ")", ";", "i", "++", ")", "if", "(", "pair", "==", "match", "[", "i", "]", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "REG1", "and", "REG2", "match", "the", "criteria", "for", "a", "movep", "insn", "." ]

[ "mips", "8", "0x00000060", "0x000000a0", "0x000000c0", "0x00200010", "0x00400010", "0x00000030", "0x00000050", "0x00000090", "1", "1", "0" ]

[]

[ "<s>", "void", "WebAssemblyAsmPrinter", "::", "emitJumpTableInfo", "(", ")", "{", "}", "</s>" ]

[ "Print", "assembly", "representations", "of", "the", "jump", "tables", "used", "by", "the", "current", "function", "to", "the", "current", "output", "stream", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "llvm_unreachable", "(", "\"Handled by fixupNeedsRelaxationAdvanced\"", ")", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "RI5CY", "\"Handled by fixupNeedsRelaxationAdvanced\"" ]

[]

[ "<s>", "const", "HexagonSubtarget", "*", "HexagonTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "AttributeList", "FnAttrs", "=", "F", ".", "getAttributes", "(", ")", ";", "Attribute", "CPUAttr", "=", "FnAttrs", ".", "getAttribute", "(", "AttributeList", "::", "FunctionIndex", ",", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "FnAttrs", ".", "getAttribute", "(", "AttributeList", "::", "FunctionIndex", ",", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "HexagonSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "\"target-cpu\"", "\"target-features\"", "Hexagon" ]

[]

[ "<s>", "bool", "arm_valid_symbolic_address_p", "(", "rtx", "addr", ")", "{", "rtx", "xop0", ",", "xop1", "=", "NULL_RTX", ";", "rtx", "tmp", "=", "addr", ";", "if", "(", "target_word_relocations", ")", "return", "false", ";", "if", "(", "SYMBOL_REF_P", "(", "tmp", ")", "||", "LABEL_REF_P", "(", "tmp", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "CONST", ")", "tmp", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "tmp", ")", "==", "PLUS", ")", "{", "xop0", "=", "XEXP", "(", "tmp", ",", "0", ")", ";", "xop1", "=", "XEXP", "(", "tmp", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "xop0", ")", "==", "SYMBOL_REF", "&&", "CONST_INT_P", "(", "xop1", ")", ")", "{", "if", "(", "TARGET_THUMB1", "&&", "!", "TARGET_HAVE_MOVT", ")", "return", "IN_RANGE", "(", "INTVAL", "(", "xop1", ")", ",", "0", ",", "0xff", ")", ";", "else", "return", "IN_RANGE", "(", "INTVAL", "(", "xop1", ")", ",", "-", "0x8000", ",", "0x7fff", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "pattern", "is", "a", "valid", "symbolic", "address", ",", "which", "is", "either", "a", "symbol_ref", "or", "(", "symbol_ref", "+", "addend", ")", ".", "According", "to", "the", "ARM", "ELF", "ABI", ",", "the", "initial", "addend", "of", "REL-type", "relocations", "processing", "MOVW", "and", "MOVT", "instructions", "is", "formed", "by", "interpreting", "the", "16-bit", "literal", "field", "of", "the", "instruction", "as", "a", "16-bit", "signed", "value", "in", "the", "range", "-32768", "<", "=", "A", "<", "32768", ".", "In", "Thumb-1", "mode", ",", "we", "use", "upper/lower", "relocations", "which", "have", "an", "8-bit", "unsigned", "range", "of", "0", "<", "=", "A", "<", "256", "as", "described", "in", "the", "AAELF32", "relocation", "handling", "documentation", ":", "REL-type", "relocations", "are", "encoded", "as", "unsigned", "in", "this", "case", "." ]

[ "arm", "0", "0", "1", "0", "0xff", "0x8000", "0x7fff" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "MCP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "for", "(", "auto", "*", "GV", ":", "AFI", "->", "getGlobalsPromotedToConstantPool", "(", ")", ")", "PromotedGlobals", ".", "insert", "(", "GV", ")", ";", "unsigned", "OptimizationGoal", ";", "if", "(", "F", ".", "hasOptNone", "(", ")", ")", "OptimizationGoal", "=", "6", ";", "else", "if", "(", "F", ".", "hasMinSize", "(", ")", ")", "OptimizationGoal", "=", "4", ";", "else", "if", "(", "F", ".", "hasOptSize", "(", ")", ")", "OptimizationGoal", "=", "3", ";", "else", "if", "(", "TM", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", ")", "OptimizationGoal", "=", "2", ";", "else", "if", "(", "TM", ".", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "OptimizationGoal", "=", "1", ";", "else", "OptimizationGoal", "=", "5", ";", "if", "(", "OptimizationGoals", "==", "-", "1", ")", "OptimizationGoals", "=", "OptimizationGoal", ";", "else", "if", "(", "OptimizationGoals", "!=", "(", "int", ")", "OptimizationGoal", ")", "OptimizationGoals", "=", "0", ";", "if", "(", "Subtarget", "->", "isTargetCOFF", "(", ")", ")", "{", "bool", "Internal", "=", "F", ".", "hasInternalLinkage", "(", ")", ";", "COFF", "::", "SymbolStorageClass", "Scl", "=", "Internal", "?", "COFF", "::", "IMAGE_SYM_CLASS_STATIC", ":", "COFF", "::", "IMAGE_SYM_CLASS_EXTERNAL", ";", "int", "Type", "=", "COFF", "::", "IMAGE_SYM_DTYPE_FUNCTION", "<<", "COFF", "::", "SCT_COMPLEX_TYPE_SHIFT", ";", "OutStreamer", "->", "BeginCOFFSymbolDef", "(", "CurrentFnSym", ")", ";", "OutStreamer", "->", "emitCOFFSymbolStorageClass", "(", "Scl", ")", ";", "OutStreamer", "->", "emitCOFFSymbolType", "(", "Type", ")", ";", "OutStreamer", "->", "EndCOFFSymbolDef", "(", ")", ";", "}", "emitFunctionBody", "(", ")", ";", "emitXRayTable", "(", ")", ";", "if", "(", "!", "ThumbIndirectPads", ".", "empty", "(", ")", ")", "{", "OutStreamer", "->", "emitAssemblerFlag", "(", "MCAF_Code16", ")", ";", "emitAlignment", "(", "Align", "(", "2", ")", ")", ";", "for", "(", "std", "::", "pair", "<", "unsigned", ",", "MCSymbol", "*", ">", "&", "TIP", ":", "ThumbIndirectPads", ")", "{", "OutStreamer", "->", "emitLabel", "(", "TIP", ".", "second", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "MCInstBuilder", "(", "ARM", "::", "tBX", ")", ".", "addReg", "(", "TIP", ".", "first", ")", ".", "addImm", "(", "ARMCC", "::", "AL", ")", ".", "addReg", "(", "0", ")", ")", ";", "}", "ThumbIndirectPads", ".", "clear", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "6", "4", "3", "2", "1", "5", "1", "0", "2", "ARM::tBX", "ARMCC::AL", "0" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "SplitVectorStore", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "StoreSDNode", "*", "Store", "=", "cast", "<", "StoreSDNode", ">", "(", "Op", ")", ";", "SDValue", "Val", "=", "Store", "->", "getValue", "(", ")", ";", "EVT", "VT", "=", "Val", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "2", ")", "return", "ScalarizeVectorStore", "(", "Op", ",", "DAG", ")", ";", "EVT", "MemVT", "=", "Store", "->", "getMemoryVT", "(", ")", ";", "SDValue", "Chain", "=", "Store", "->", "getChain", "(", ")", ";", "SDValue", "BasePtr", "=", "Store", "->", "getBasePtr", "(", ")", ";", "SDLoc", "SL", "(", "Op", ")", ";", "EVT", "LoVT", ",", "HiVT", ";", "EVT", "LoMemVT", ",", "HiMemVT", ";", "SDValue", "Lo", ",", "Hi", ";", "std", "::", "tie", "(", "LoVT", ",", "HiVT", ")", "=", "DAG", ".", "GetSplitDestVTs", "(", "VT", ")", ";", "std", "::", "tie", "(", "LoMemVT", ",", "HiMemVT", ")", "=", "DAG", ".", "GetSplitDestVTs", "(", "MemVT", ")", ";", "std", "::", "tie", "(", "Lo", ",", "Hi", ")", "=", "DAG", ".", "SplitVector", "(", "Val", ",", "SL", ",", "LoVT", ",", "HiVT", ")", ";", "EVT", "PtrVT", "=", "BasePtr", ".", "getValueType", "(", ")", ";", "SDValue", "HiPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "SL", ",", "PtrVT", ",", "BasePtr", ",", "DAG", ".", "getConstant", "(", "LoMemVT", ".", "getStoreSize", "(", ")", ",", "SL", ",", "PtrVT", ")", ")", ";", "MachinePointerInfo", "SrcValue", "(", "Store", "->", "getMemOperand", "(", ")", "->", "getValue", "(", ")", ")", ";", "SDValue", "LoStore", "=", "DAG", ".", "getTruncStore", "(", "Chain", ",", "SL", ",", "Lo", ",", "BasePtr", ",", "SrcValue", ",", "LoMemVT", ",", "Store", "->", "isNonTemporal", "(", ")", ",", "Store", "->", "isVolatile", "(", ")", ",", "Store", "->", "getAlignment", "(", ")", ")", ";", "SDValue", "HiStore", "=", "DAG", ".", "getTruncStore", "(", "Chain", ",", "SL", ",", "Hi", ",", "HiPtr", ",", "SrcValue", ".", "getWithOffset", "(", "LoMemVT", ".", "getStoreSize", "(", ")", ")", ",", "HiMemVT", ",", "Store", "->", "isNonTemporal", "(", ")", ",", "Store", "->", "isVolatile", "(", ")", ",", "Store", "->", "getAlignment", "(", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "SL", ",", "MVT", "::", "Other", ",", "LoStore", ",", "HiStore", ")", ";", "}", "</s>" ]

[ "Split", "a", "vector", "store", "into", "2", "stores", "of", "half", "the", "vector", "." ]

[ "AMDGPU", "AMDGPU", "2", "ISD::ADD", "ISD::TokenFactor", "MVT::Other" ]

[]

[ "<s>", "static", "section", "*", "mips_function_rodata_section", "(", "tree", "decl", ")", "{", "if", "(", "!", "TARGET_ABICALLS", "||", "TARGET_ABSOLUTE_ABICALLS", "||", "TARGET_GPWORD", ")", "return", "default_function_rodata_section", "(", "decl", ")", ";", "if", "(", "decl", "&&", "DECL_SECTION_NAME", "(", "decl", ")", ")", "{", "const", "char", "*", "name", "=", "DECL_SECTION_NAME", "(", "decl", ")", ";", "if", "(", "DECL_COMDAT_GROUP", "(", "decl", ")", "&&", "strncmp", "(", "name", ",", "\".gnu.linkonce.t.\"", ",", "16", ")", "==", "0", ")", "{", "char", "*", "rname", "=", "ASTRDUP", "(", "name", ")", ";", "rname", "[", "14", "]", "=", "'d'", ";", "return", "get_section", "(", "rname", ",", "SECTION_LINKONCE", "|", "SECTION_WRITE", ",", "decl", ")", ";", "}", "else", "if", "(", "flag_function_sections", "&&", "flag_data_sections", "&&", "strncmp", "(", "name", ",", "\".text.\"", ",", "6", ")", "==", "0", ")", "{", "char", "*", "rname", "=", "ASTRDUP", "(", "name", ")", ";", "memcpy", "(", "rname", "+", "1", ",", "\"data\"", ",", "4", ")", ";", "return", "get_section", "(", "rname", ",", "SECTION_WRITE", ",", "decl", ")", ";", "}", "}", "return", "data_section", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_FUNCTION_RODATA_SECTION", ".", "The", "complication", "here", "is", "that", ",", "with", "the", "combination", "TARGET_ABICALLS", "&", "&", "!", "TARGET_GPWORD", ",", "jump", "tables", "will", "use", "absolute", "addresses", ",", "and", "should", "therefore", "not", "be", "included", "in", "the", "read-only", "part", "of", "a", "DSO", ".", "Handle", "such", "cases", "by", "selecting", "a", "normal", "data", "section", "instead", "of", "a", "read-only", "one", ".", "The", "logic", "apes", "that", "in", "default_function_rodata_section", "." ]

[ "mips", "\".gnu.linkonce.t.\"", "16", "0", "14", "\".text.\"", "6", "0", "1", "\"data\"", "4" ]

[]

[ "<s>", "void", "M88kFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "M88kInstrInfo", "&", "LII", "=", "*", "static_cast", "<", "const", "M88kInstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "StackSize", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "LII", ".", "get", "(", "M88k", "::", "ADDUri", ")", ")", ".", "addReg", "(", "M88k", "::", "R31", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "M88k", "::", "R31", ")", ".", "addImm", "(", "StackSize", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "}", "</s>" ]

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

[ "M88k", "M88k", "M88k", "M88k", "M88k::ADDUri", "M88k::R31", "M88k::R31" ]

[]

[ "<s>", "static", "void", "arc_init", "(", "void", ")", "{", "if", "(", "TARGET_V2", ")", "{", "if", "(", "TARGET_MPYW", "||", "TARGET_MULTI", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "}", "if", "(", "arc_multcost", "<", "0", ")", "switch", "(", "arc_tune", ")", "{", "case", "TUNE_ARC700_4_2_STD", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "if", "(", "TARGET_NOMPY_SET", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "case", "TUNE_ARC700_4_2_XMAC", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "if", "(", "TARGET_NOMPY_SET", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "case", "TUNE_ARC600", ":", "if", "(", "TARGET_MUL64_SET", ")", "{", "arc_multcost", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "break", ";", "}", "default", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "}", "if", "(", "TARGET_NOMPY_SET", "&&", "TARGET_ARC600_FAMILY", ")", "error", "(", "\"-mno-mpy supported only for ARC700 or ARCv2\"", ")", ";", "if", "(", "!", "TARGET_DPFP", "&&", "TARGET_DPFP_DISABLE_LRSR", ")", "error", "(", "\"-mno-dpfp-lrsr supported only with -mdpfp\"", ")", ";", "if", "(", "(", "TARGET_DPFP_FAST_SET", "&&", "TARGET_DPFP_COMPACT_SET", ")", "||", "(", "TARGET_SPFP_FAST_SET", "&&", "TARGET_SPFP_COMPACT_SET", ")", ")", "error", "(", "\"FPX fast and compact options cannot be specified together\"", ")", ";", "if", "(", "TARGET_SPFP_FAST_SET", "&&", "TARGET_ARC600_FAMILY", ")", "error", "(", "\"-mspfp_fast not available on ARC600 or ARC601\"", ")", ";", "if", "(", "(", "TARGET_DPFP_FAST_SET", "||", "TARGET_DPFP_COMPACT_SET", "||", "TARGET_SPFP", ")", "&&", "TARGET_HARD_FLOAT", ")", "error", "(", "\"No FPX/FPU mixing allowed\"", ")", ";", "if", "(", "flag_pic", "&&", "TARGET_ARC600_FAMILY", ")", "{", "warning", "(", "DK_WARNING", ",", "\"PIC is not supported for %s. Generating non-PIC code only..\"", ",", "arc_cpu_string", ")", ";", "flag_pic", "=", "0", ";", "}", "arc_init_reg_tables", "(", ")", ";", "memset", "(", "arc_punct_chars", ",", "0", ",", "sizeof", "(", "arc_punct_chars", ")", ")", ";", "arc_punct_chars", "[", "'#'", "]", "=", "1", ";", "arc_punct_chars", "[", "'*'", "]", "=", "1", ";", "arc_punct_chars", "[", "'?'", "]", "=", "1", ";", "arc_punct_chars", "[", "'!'", "]", "=", "1", ";", "arc_punct_chars", "[", "'^'", "]", "=", "1", ";", "arc_punct_chars", "[", "'&'", "]", "=", "1", ";", "arc_punct_chars", "[", "'+'", "]", "=", "1", ";", "arc_punct_chars", "[", "'_'", "]", "=", "1", ";", "if", "(", "optimize", ">", "1", "&&", "!", "TARGET_NO_COND_EXEC", ")", "{", "opt_pass", "*", "pass_arc_ifcvt_4", "=", "make_pass_arc_ifcvt", "(", "g", ")", ";", "struct", "register_pass_info", "arc_ifcvt4_info", "=", "{", "pass_arc_ifcvt_4", ",", "\"dbr\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "struct", "register_pass_info", "arc_ifcvt5_info", "=", "{", "pass_arc_ifcvt_4", "->", "clone", "(", ")", ",", "\"shorten\"", ",", "1", ",", "PASS_POS_INSERT_BEFORE", "}", ";", "register_pass", "(", "&", "arc_ifcvt4_info", ")", ";", "register_pass", "(", "&", "arc_ifcvt5_info", ")", ";", "}", "if", "(", "flag_delayed_branch", ")", "{", "opt_pass", "*", "pass_arc_predicate_delay_insns", "=", "make_pass_arc_predicate_delay_insns", "(", "g", ")", ";", "struct", "register_pass_info", "arc_predicate_delay_info", "=", "{", "pass_arc_predicate_delay_insns", ",", "\"dbr\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "register_pass", "(", "&", "arc_predicate_delay_info", ")", ";", "}", "}", "</s>" ]

[ "Called", "by", "OVERRIDE_OPTIONS", "to", "initialize", "various", "things", "." ]

[ "arc", "1", "0", "4", "30", "3", "30", "4", "30", "\"-mno-mpy supported only for ARC700 or ARCv2\"", "\"-mno-dpfp-lrsr supported only with -mdpfp\"", "\"FPX fast and compact options cannot be specified together\"", "\"-mspfp_fast not available on ARC600 or ARC601\"", "\"No FPX/FPU mixing allowed\"", "\"PIC is not supported for %s. Generating non-PIC code only..\"", "0", "0", "1", "1", "1", "1", "1", "1", "1", "1", "1", "\"dbr\"", "1", "\"shorten\"", "1", "\"dbr\"", "1" ]

[]

[ "<s>", "static", "void", "ia64_asm_init_sections", "(", "void", ")", "{", "exception_section", "=", "get_unnamed_section", "(", "0", ",", "output_section_asm_op", ",", "\"\\t.handlerdata\"", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_INITIALIZE_SECTIONS", "." ]

[ "ia64", "0", "\"\\t.handlerdata\"" ]

[]

[ "<s>", "bool", "supportSplitCSR", "(", "MachineFunction", "*", "MF", ")", "const", "override", "{", "return", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CXX_FAST_TLS", "&&", "MF", "->", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "that", "a", "subset", "of", "CSRs", "for", "the", "given", "machine", "function", "is", "handled", "explicitly", "via", "copies", "." ]

[ "ARM" ]

[]

[ "<s>", "bool", "isVirtualSection", "(", "const", "MCSection", "&", "Section", ")", "const", "{", "const", "MCSectionMachO", "&", "SMO", "=", "static_cast", "<", "const", "MCSectionMachO", "&", ">", "(", "Section", ")", ";", "return", "(", "SMO", ".", "getType", "(", ")", "==", "MCSectionMachO", "::", "S_ZEROFILL", "||", "SMO", ".", "getType", "(", ")", "==", "MCSectionMachO", "::", "S_GB_ZEROFILL", "||", "SMO", ".", "getType", "(", ")", "==", "MCSectionMachO", "::", "S_THREAD_LOCAL_ZEROFILL", ")", ";", "}", "</s>" ]

[ "Check", "whether", "this", "section", "is", "``", "virtual", "''", ",", "that", "is", "has", "no", "actual", "object", "file", "contents", "." ]

[ "X86" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getScalarType", "(", ")", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", "==", "MVT", "::", "f32", "||", "VT", ".", "getScalarType", "(", ")", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", "==", "MVT", "::", "f64", ")", "{", "return", "true", ";", "}", "else", "{", "return", "false", ";", "}", "}", "</s>" ]

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

[ "R600", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "void", "mips_move_integer", "(", "rtx", "temp", ",", "rtx", "dest", ",", "unsigned", "HOST_WIDE_INT", "value", ")", "{", "struct", "mips_integer_op", "codes", "[", "MIPS_MAX_INTEGER_OPS", "]", ";", "machine_mode", "mode", ";", "unsigned", "int", "i", ",", "num_ops", ";", "rtx", "x", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "num_ops", "=", "mips_build_integer", "(", "codes", ",", "value", ")", ";", "x", "=", "GEN_INT", "(", "codes", "[", "0", "]", ".", "value", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<", "num_ops", ";", "i", "++", ")", "{", "if", "(", "!", "can_create_pseudo_p", "(", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp", ",", "x", ")", ")", ";", "x", "=", "temp", ";", "}", "else", "x", "=", "force_reg", "(", "mode", ",", "x", ")", ";", "x", "=", "gen_rtx_fmt_ee", "(", "codes", "[", "i", "]", ".", "code", ",", "mode", ",", "x", ",", "GEN_INT", "(", "codes", "[", "i", "]", ".", "value", ")", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "x", ")", ")", ";", "}", "</s>" ]

[ "Move", "VALUE", "into", "register", "DEST", "." ]

[ "mips", "0", "1" ]

[]

[ "<s>", "bool", "Thumb1FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "bool", "isVarArg", "=", "AFI", "->", "getArgRegsSaveSize", "(", ")", ">", "0", ";", "DebugLoc", "DL", "=", "MI", "!=", "MBB", ".", "end", "(", ")", "?", "MI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tPOP", ")", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "bool", "NumRegs", "=", "false", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "ARM", "::", "LR", "&&", "MBB", ".", "succ_empty", "(", ")", ")", "{", "if", "(", "isVarArg", ")", "continue", ";", "if", "(", "STI", ".", "hasV4TOps", "(", ")", "&&", "!", "STI", ".", "hasV5TOps", "(", ")", ")", "continue", ";", "Reg", "=", "ARM", "::", "PC", ";", "(", "*", "MIB", ")", ".", "setDesc", "(", "TII", ".", "get", "(", "ARM", "::", "tPOP_RET", ")", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "MIB", ".", "copyImplicitOps", "(", "&", "*", "MI", ")", ";", "MI", "=", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "MIB", ".", "addReg", "(", "Reg", ",", "getDefRegState", "(", "true", ")", ")", ";", "NumRegs", "=", "true", ";", "}", "if", "(", "NumRegs", ")", "MBB", ".", "insert", "(", "MI", ",", "&", "*", "MIB", ")", ";", "else", "MF", ".", "DeleteMachineInstr", "(", "MIB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "0", "ARM::tPOP", "0", "1", "ARM::LR", "ARM::PC", "ARM::tPOP_RET" ]

[]

[ "<s>", "int", "const_ok_for_op", "(", "HOST_WIDE_INT", "i", ",", "enum", "rtx_code", "code", ")", "{", "if", "(", "const_ok_for_arm", "(", "i", ")", ")", "return", "1", ";", "switch", "(", "code", ")", "{", "case", "SET", ":", "if", "(", "arm_arch_thumb2", "&&", "(", "i", "&", "0xffff0000", ")", "==", "0", ")", "return", "1", ";", "else", "return", "const_ok_for_arm", "(", "ARM_SIGN_EXTEND", "(", "~", "i", ")", ")", ";", "case", "PLUS", ":", "if", "(", "TARGET_THUMB2", "&&", "(", "(", "i", "&", "0xfffff000", ")", "==", "0", "||", "(", "(", "-", "i", ")", "&", "0xfffff000", ")", "==", "0", ")", ")", "return", "1", ";", "case", "COMPARE", ":", "case", "EQ", ":", "case", "NE", ":", "case", "GT", ":", "case", "LE", ":", "case", "LT", ":", "case", "GE", ":", "case", "GEU", ":", "case", "LTU", ":", "case", "GTU", ":", "case", "LEU", ":", "case", "UNORDERED", ":", "case", "ORDERED", ":", "case", "UNEQ", ":", "case", "UNGE", ":", "case", "UNLT", ":", "case", "UNGT", ":", "case", "UNLE", ":", "return", "const_ok_for_arm", "(", "ARM_SIGN_EXTEND", "(", "-", "i", ")", ")", ";", "case", "MINUS", ":", "case", "XOR", ":", "return", "0", ";", "case", "IOR", ":", "if", "(", "TARGET_THUMB2", ")", "return", "const_ok_for_arm", "(", "ARM_SIGN_EXTEND", "(", "~", "i", ")", ")", ";", "return", "0", ";", "case", "AND", ":", "return", "const_ok_for_arm", "(", "ARM_SIGN_EXTEND", "(", "~", "i", ")", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "I", "is", "a", "valid", "constant", "for", "the", "operation", "CODE", "." ]

[ "arm", "1", "0xffff0000", "0", "1", "0xfffff000", "0", "0xfffff000", "0", "1", "0", "0" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "SITargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "!", "isTypeLegal", "(", "VT", ")", ")", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'s'", ":", "case", "'r'", ":", "switch", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "default", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "nullptr", ")", ";", "case", "32", ":", "case", "16", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "case", "64", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", ";", "case", "128", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "SReg_128RegClass", ")", ";", "case", "256", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "SReg_256RegClass", ")", ";", "}", "case", "'v'", ":", "switch", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "default", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "nullptr", ")", ";", "case", "32", ":", "case", "16", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "case", "64", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "VReg_64RegClass", ")", ";", "case", "96", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "VReg_96RegClass", ")", ";", "case", "128", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "VReg_128RegClass", ")", ";", "case", "256", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "VReg_256RegClass", ")", ";", "case", "512", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "VReg_512RegClass", ")", ";", "}", "}", "}", "if", "(", "Constraint", ".", "size", "(", ")", ">", "1", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "if", "(", "Constraint", "[", "1", "]", "==", "'v'", ")", "{", "RC", "=", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "}", "else", "if", "(", "Constraint", "[", "1", "]", "==", "'s'", ")", "{", "RC", "=", "&", "AMDGPU", "::", "SGPR_32RegClass", ";", "}", "if", "(", "RC", ")", "{", "uint32_t", "Idx", ";", "bool", "Failed", "=", "Constraint", ".", "substr", "(", "2", ")", ".", "getAsInteger", "(", "10", ",", "Idx", ")", ";", "if", "(", "!", "Failed", "&&", "Idx", "<", "RC", "->", "getNumRegs", "(", ")", ")", "return", "std", "::", "make_pair", "(", "RC", "->", "getRegister", "(", "Idx", ")", ",", "RC", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "1", "0", "0U", "32", "16", "0U", "AMDGPU::SReg_32_XM0RegClass", "64", "0U", "AMDGPU::SGPR_64RegClass", "128", "0U", "AMDGPU::SReg_128RegClass", "256", "0U", "AMDGPU::SReg_256RegClass", "0U", "32", "16", "0U", "AMDGPU::VGPR_32RegClass", "64", "0U", "AMDGPU::VReg_64RegClass", "96", "0U", "AMDGPU::VReg_96RegClass", "128", "0U", "AMDGPU::VReg_128RegClass", "256", "0U", "AMDGPU::VReg_256RegClass", "512", "0U", "AMDGPU::VReg_512RegClass", "1", "1", "AMDGPU::VGPR_32RegClass", "1", "AMDGPU::SGPR_32RegClass", "2", "10" ]

[]

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

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

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

[]

[ "<s>", "bool", "X86InstrInfo", "::", "areLoadsFromSameBasePtr", "(", "SDNode", "*", "Load1", ",", "SDNode", "*", "Load2", ",", "int64_t", "&", "Offset1", ",", "int64_t", "&", "Offset2", ")", "const", "{", "if", "(", "!", "Load1", "->", "isMachineOpcode", "(", ")", "||", "!", "Load2", "->", "isMachineOpcode", "(", ")", ")", "return", "false", ";", "unsigned", "Opc1", "=", "Load1", "->", "getMachineOpcode", "(", ")", ";", "unsigned", "Opc2", "=", "Load2", "->", "getMachineOpcode", "(", ")", ";", "switch", "(", "Opc1", ")", "{", "default", ":", "return", "false", ";", "case", "X86", "::", "MOV8rm", ":", "case", "X86", "::", "MOV16rm", ":", "case", "X86", "::", "MOV32rm", ":", "case", "X86", "::", "MOV64rm", ":", "case", "X86", "::", "LD_Fp32m", ":", "case", "X86", "::", "LD_Fp64m", ":", "case", "X86", "::", "LD_Fp80m", ":", "case", "X86", "::", "MOVSSrm", ":", "case", "X86", "::", "MOVSDrm", ":", "case", "X86", "::", "MMX_MOVD64rm", ":", "case", "X86", "::", "MMX_MOVQ64rm", ":", "case", "X86", "::", "FsMOVAPSrm", ":", "case", "X86", "::", "FsMOVAPDrm", ":", "case", "X86", "::", "MOVAPSrm", ":", "case", "X86", "::", "MOVUPSrm", ":", "case", "X86", "::", "MOVUPSrm_Int", ":", "case", "X86", "::", "MOVAPDrm", ":", "case", "X86", "::", "MOVDQArm", ":", "case", "X86", "::", "MOVDQUrm", ":", "case", "X86", "::", "MOVDQUrm_Int", ":", "break", ";", "}", "switch", "(", "Opc2", ")", "{", "default", ":", "return", "false", ";", "case", "X86", "::", "MOV8rm", ":", "case", "X86", "::", "MOV16rm", ":", "case", "X86", "::", "MOV32rm", ":", "case", "X86", "::", "MOV64rm", ":", "case", "X86", "::", "LD_Fp32m", ":", "case", "X86", "::", "LD_Fp64m", ":", "case", "X86", "::", "LD_Fp80m", ":", "case", "X86", "::", "MOVSSrm", ":", "case", "X86", "::", "MOVSDrm", ":", "case", "X86", "::", "MMX_MOVD64rm", ":", "case", "X86", "::", "MMX_MOVQ64rm", ":", "case", "X86", "::", "FsMOVAPSrm", ":", "case", "X86", "::", "FsMOVAPDrm", ":", "case", "X86", "::", "MOVAPSrm", ":", "case", "X86", "::", "MOVUPSrm", ":", "case", "X86", "::", "MOVUPSrm_Int", ":", "case", "X86", "::", "MOVAPDrm", ":", "case", "X86", "::", "MOVDQArm", ":", "case", "X86", "::", "MOVDQUrm", ":", "case", "X86", "::", "MOVDQUrm_Int", ":", "break", ";", "}", "if", "(", "Load1", "->", "getOperand", "(", "0", ")", "!=", "Load2", "->", "getOperand", "(", "0", ")", "||", "Load1", "->", "getOperand", "(", "5", ")", "!=", "Load2", "->", "getOperand", "(", "5", ")", ")", "return", "false", ";", "if", "(", "Load1", "->", "getOperand", "(", "4", ")", "!=", "Load2", "->", "getOperand", "(", "4", ")", ")", "return", "false", ";", "if", "(", "Load1", "->", "getOperand", "(", "1", ")", "==", "Load2", "->", "getOperand", "(", "1", ")", "&&", "Load1", "->", "getOperand", "(", "2", ")", "==", "Load2", "->", "getOperand", "(", "2", ")", ")", "{", "if", "(", "cast", "<", "ConstantSDNode", ">", "(", "Load1", "->", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", "!=", "1", ")", "return", "false", ";", "SDValue", "Op2", "=", "Load1", "->", "getOperand", "(", "2", ")", ";", "if", "(", "!", "isa", "<", "RegisterSDNode", ">", "(", "Op2", ")", "||", "cast", "<", "RegisterSDNode", ">", "(", "Op2", ")", "->", "getReg", "(", ")", "!=", "0", ")", "return", "0", ";", "if", "(", "isa", "<", "ConstantSDNode", ">", "(", "Load1", "->", "getOperand", "(", "3", ")", ")", "&&", "isa", "<", "ConstantSDNode", ">", "(", "Load2", "->", "getOperand", "(", "3", ")", ")", ")", "{", "Offset1", "=", "cast", "<", "ConstantSDNode", ">", "(", "Load1", "->", "getOperand", "(", "3", ")", ")", "->", "getSExtValue", "(", ")", ";", "Offset2", "=", "cast", "<", "ConstantSDNode", ">", "(", "Load2", "->", "getOperand", "(", "3", ")", ")", "->", "getSExtValue", "(", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "areLoadsFromSameBasePtr", "-", "This", "is", "used", "by", "the", "pre-regalloc", "scheduler", "to", "determine", "if", "two", "loads", "are", "loading", "from", "the", "same", "base", "address", "." ]

[ "X86", "X86", "X86::MOV8rm", "X86::MOV16rm", "X86::MOV32rm", "X86::MOV64rm", "X86::LD_Fp32m", "X86::LD_Fp64m", "X86::LD_Fp80m", "X86::MOVSSrm", "X86::MOVSDrm", "X86::MMX_MOVD64rm", "X86::MMX_MOVQ64rm", "X86::FsMOVAPSrm", "X86::FsMOVAPDrm", "X86::MOVAPSrm", "X86::MOVUPSrm", "X86::MOVUPSrm_Int", "X86::MOVAPDrm", "X86::MOVDQArm", "X86::MOVDQUrm", "X86::MOVDQUrm_Int", "X86::MOV8rm", "X86::MOV16rm", "X86::MOV32rm", "X86::MOV64rm", "X86::LD_Fp32m", "X86::LD_Fp64m", "X86::LD_Fp80m", "X86::MOVSSrm", "X86::MOVSDrm", "X86::MMX_MOVD64rm", "X86::MMX_MOVQ64rm", "X86::FsMOVAPSrm", "X86::FsMOVAPDrm", "X86::MOVAPSrm", "X86::MOVUPSrm", "X86::MOVUPSrm_Int", "X86::MOVAPDrm", "X86::MOVDQArm", "X86::MOVDQUrm", "X86::MOVDQUrm_Int", "0", "0", "5", "5", "4", "4", "1", "1", "2", "2", "1", "1", "2", "0", "0", "3", "3", "3", "3" ]

[]

[ "<s>", "static", "bool", "mips_split_addresses_p", "(", "void", ")", "{", "return", "(", "TARGET_SPLIT_ADDRESSES", "&&", "optimize", "&&", "!", "TARGET_MIPS16", "&&", "!", "flag_pic", "&&", "!", "ABI_HAS_64BIT_SYMBOLS", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "-msplit-addresses", "is", "selected", "and", "should", "be", "honored", ".", "-msplit-addresses", "is", "a", "half-way", "house", "between", "explicit", "relocations", "and", "the", "traditional", "assembler", "macros", ".", "It", "can", "split", "absolute", "32-bit", "symbolic", "constants", "into", "a", "high/lo_sum", "pair", "but", "uses", "macros", "for", "other", "sorts", "of", "access", ".", "Like", "explicit", "relocation", "support", "for", "REL", "targets", ",", "it", "relies", "on", "GNU", "extensions", "in", "the", "assembler", "and", "the", "linker", ".", "Although", "this", "code", "should", "work", "for", "-O0", ",", "it", "has", "traditionally", "been", "treated", "as", "an", "optimization", "." ]

[ "mips" ]

[]

[ "<s>", "unsigned", "getCacheLineSize", "(", ")", "{", "return", "256", ";", "}", "</s>" ]

[ "Return", "the", "target", "cache", "line", "size", "in", "bytes", "." ]

[ "SystemZ", "256" ]

[]

[ "<s>", "const", "NyuziMCExpr", "*", "NyuziMCExpr", "::", "create", "(", "VariantKind", "Kind", ",", "const", "MCExpr", "*", "Expr", ",", "MCContext", "&", "Ctx", ")", "{", "return", "new", "(", "Ctx", ")", "NyuziMCExpr", "(", "Kind", ",", "Expr", ")", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

[ "Nyuzi", "Nyuzi", "Nyuzi", "Nyuzi" ]

[]

[ "<s>", "void", "J2MCCodeEmitter", "::", "EmitInstruction", "(", "uint64_t", "Val", ",", "unsigned", "Size", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Size", ";", "++", "i", ")", "{", "unsigned", "Shift", "=", "i", "*", "8", ";", "EmitByte", "(", "(", "Val", ">>", "Shift", ")", "&", "0xff", ",", "OS", ")", ";", "}", "}", "</s>" ]

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

[ "J2", "J2", "0", "8", "0xff" ]

[]

[ "<s>", "virtual", "const", "ARMSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "AArch64TargetLowering", "::", "ConstraintType", "AArch64TargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'z'", ":", "return", "C_Other", ";", "case", "'x'", ":", "case", "'w'", ":", "return", "C_RegisterClass", ";", "case", "'Q'", ":", "return", "C_Memory", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "1", "0" ]

[]

[ "<s>", "unsigned", "SparcTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"i0\"", ",", "SP", "::", "I0", ")", ".", "Case", "(", "\"i1\"", ",", "SP", "::", "I1", ")", ".", "Case", "(", "\"i2\"", ",", "SP", "::", "I2", ")", ".", "Case", "(", "\"i3\"", ",", "SP", "::", "I3", ")", ".", "Case", "(", "\"i4\"", ",", "SP", "::", "I4", ")", ".", "Case", "(", "\"i5\"", ",", "SP", "::", "I5", ")", ".", "Case", "(", "\"i6\"", ",", "SP", "::", "I6", ")", ".", "Case", "(", "\"i7\"", ",", "SP", "::", "I7", ")", ".", "Case", "(", "\"o0\"", ",", "SP", "::", "O0", ")", ".", "Case", "(", "\"o1\"", ",", "SP", "::", "O1", ")", ".", "Case", "(", "\"o2\"", ",", "SP", "::", "O2", ")", ".", "Case", "(", "\"o3\"", ",", "SP", "::", "O3", ")", ".", "Case", "(", "\"o4\"", ",", "SP", "::", "O4", ")", ".", "Case", "(", "\"o5\"", ",", "SP", "::", "O5", ")", ".", "Case", "(", "\"o6\"", ",", "SP", "::", "O6", ")", ".", "Case", "(", "\"o7\"", ",", "SP", "::", "O7", ")", ".", "Case", "(", "\"l0\"", ",", "SP", "::", "L0", ")", ".", "Case", "(", "\"l1\"", ",", "SP", "::", "L1", ")", ".", "Case", "(", "\"l2\"", ",", "SP", "::", "L2", ")", ".", "Case", "(", "\"l3\"", ",", "SP", "::", "L3", ")", ".", "Case", "(", "\"l4\"", ",", "SP", "::", "L4", ")", ".", "Case", "(", "\"l5\"", ",", "SP", "::", "L5", ")", ".", "Case", "(", "\"l6\"", ",", "SP", "::", "L6", ")", ".", "Case", "(", "\"l7\"", ",", "SP", "::", "L7", ")", ".", "Case", "(", "\"g0\"", ",", "SP", "::", "G0", ")", ".", "Case", "(", "\"g1\"", ",", "SP", "::", "G1", ")", ".", "Case", "(", "\"g2\"", ",", "SP", "::", "G2", ")", ".", "Case", "(", "\"g3\"", ",", "SP", "::", "G3", ")", ".", "Case", "(", "\"g4\"", ",", "SP", "::", "G4", ")", ".", "Case", "(", "\"g5\"", ",", "SP", "::", "G5", ")", ".", "Case", "(", "\"g6\"", ",", "SP", "::", "G6", ")", ".", "Case", "(", "\"g7\"", ",", "SP", "::", "G7", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "Sparc", "Sparc", "\"i0\"", "SP::I0", "\"i1\"", "SP::I1", "\"i2\"", "SP::I2", "\"i3\"", "SP::I3", "\"i4\"", "SP::I4", "\"i5\"", "SP::I5", "\"i6\"", "SP::I6", "\"i7\"", "SP::I7", "\"o0\"", "SP::O0", "\"o1\"", "SP::O1", "\"o2\"", "SP::O2", "\"o3\"", "SP::O3", "\"o4\"", "SP::O4", "\"o5\"", "SP::O5", "\"o6\"", "SP::O6", "\"o7\"", "SP::O7", "\"l0\"", "SP::L0", "\"l1\"", "SP::L1", "\"l2\"", "SP::L2", "\"l3\"", "SP::L3", "\"l4\"", "SP::L4", "\"l5\"", "SP::L5", "\"l6\"", "SP::L6", "\"l7\"", "SP::L7", "\"g0\"", "SP::G0", "\"g1\"", "SP::G1", "\"g2\"", "SP::G2", "\"g3\"", "SP::G3", "\"g4\"", "SP::G4", "\"g5\"", "SP::G5", "\"g6\"", "SP::G6", "\"g7\"", "SP::G7", "0", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "bool", "X86DomainReassignment", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "DisableX86DomainReassignment", ")", "return", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** Machine Function before Domain Reassignment *****\\n\"", ")", ";", "DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", ")", ")", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "STI", "->", "hasAVX512", "(", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "assert", "(", "MRI", "->", "isSSA", "(", ")", "&&", "\"Expected MIR to be in SSA form\"", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "initConverters", "(", ")", ";", "bool", "Changed", "=", "false", ";", "EnclosedEdges", ".", "clear", "(", ")", ";", "EnclosedInstrs", ".", "clear", "(", ")", ";", "std", "::", "vector", "<", "Closure", ">", "Closures", ";", "unsigned", "ClosureID", "=", "0", ";", "for", "(", "unsigned", "Idx", "=", "0", ";", "Idx", "<", "MRI", "->", "getNumVirtRegs", "(", ")", ";", "++", "Idx", ")", "{", "unsigned", "Reg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "Idx", ")", ";", "if", "(", "!", "isGPR", "(", "MRI", "->", "getRegClass", "(", "Reg", ")", ")", ")", "continue", ";", "if", "(", "EnclosedEdges", ".", "count", "(", "Reg", ")", ")", "continue", ";", "Closure", "C", "(", "ClosureID", "++", ",", "{", "MaskDomain", "}", ")", ";", "buildClosure", "(", "C", ",", "Reg", ")", ";", "if", "(", "!", "C", ".", "empty", "(", ")", "&&", "C", ".", "isLegal", "(", "MaskDomain", ")", ")", "Closures", ".", "push_back", "(", "std", "::", "move", "(", "C", ")", ")", ";", "}", "for", "(", "Closure", "&", "C", ":", "Closures", ")", "{", "DEBUG", "(", "C", ".", "dump", "(", "MRI", ")", ")", ";", "if", "(", "isReassignmentProfitable", "(", "C", ",", "MaskDomain", ")", ")", "{", "reassign", "(", "C", ",", "MaskDomain", ")", ";", "++", "NumClosuresConverted", ";", "Changed", "=", "true", ";", "}", "}", "DeleteContainerSeconds", "(", "Converters", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** Machine Function after Domain Reassignment *****\\n\"", ")", ";", "DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", ")", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"***** Machine Function before Domain Reassignment *****\\n\"", "X86", "\"Expected MIR to be in SSA form\"", "0", "0", "\"***** Machine Function after Domain Reassignment *****\\n\"" ]

[]

[ "<s>", "int", "direct_return_p", "(", "void", ")", "{", "frv_stack_t", "*", "info", ";", "if", "(", "!", "reload_completed", ")", "return", "FALSE", ";", "info", "=", "frv_stack_info", "(", ")", ";", "return", "(", "info", "->", "total_size", "==", "0", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "bare", "return", "instruction", "can", "be", "used", "outside", "of", "the", "epilog", "code", ".", "For", "frv", ",", "we", "only", "do", "it", "if", "there", "was", "no", "stack", "allocation", "." ]

[ "frv", "0" ]

[]

[ "<s>", "void", "WebAssemblyExceptionInfo", "::", "recalculate", "(", "MachineDominatorTree", "&", "MDT", ",", "const", "MachineDominanceFrontier", "&", "MDF", ")", "{", "SmallVector", "<", "std", "::", "unique_ptr", "<", "WebAssemblyException", ">", ",", "8", ">", "Exceptions", ";", "for", "(", "auto", "DomNode", ":", "post_order", "(", "&", "MDT", ")", ")", "{", "MachineBasicBlock", "*", "EHPad", "=", "DomNode", "->", "getBlock", "(", ")", ";", "if", "(", "!", "EHPad", "->", "isEHPad", "(", ")", ")", "continue", ";", "auto", "WE", "=", "std", "::", "make_unique", "<", "WebAssemblyException", ">", "(", "EHPad", ")", ";", "discoverAndMapException", "(", "WE", ".", "get", "(", ")", ",", "MDT", ",", "MDF", ")", ";", "Exceptions", ".", "push_back", "(", "std", "::", "move", "(", "WE", ")", ")", ";", "}", "for", "(", "auto", "DomNode", ":", "post_order", "(", "&", "MDT", ")", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "DomNode", "->", "getBlock", "(", ")", ";", "WebAssemblyException", "*", "WE", "=", "getExceptionFor", "(", "MBB", ")", ";", "for", "(", ";", "WE", ";", "WE", "=", "WE", "->", "getParentException", "(", ")", ")", "WE", "->", "addBlock", "(", "MBB", ")", ";", "}", "SmallVector", "<", "WebAssemblyException", "*", ",", "8", ">", "ExceptionPointers", ";", "ExceptionPointers", ".", "reserve", "(", "Exceptions", ".", "size", "(", ")", ")", ";", "for", "(", "auto", "&", "WE", ":", "Exceptions", ")", "{", "ExceptionPointers", ".", "push_back", "(", "WE", ".", "get", "(", ")", ")", ";", "if", "(", "WE", "->", "getParentException", "(", ")", ")", "WE", "->", "getParentException", "(", ")", "->", "getSubExceptions", "(", ")", ".", "push_back", "(", "std", "::", "move", "(", "WE", ")", ")", ";", "else", "addTopLevelException", "(", "std", "::", "move", "(", "WE", ")", ")", ";", "}", "for", "(", "auto", "*", "WE", ":", "ExceptionPointers", ")", "{", "WE", "->", "reverseBlock", "(", ")", ";", "std", "::", "reverse", "(", "WE", "->", "getSubExceptions", "(", ")", ".", "begin", "(", ")", ",", "WE", "->", "getSubExceptions", "(", ")", ".", "end", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "Notify", "DTU", "that", "the", "entry", "block", "was", "replaced", "." ]

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

[]

[ "<s>", "static", "tree", "rs6000_init_stack_protect_guard", "(", "void", ")", "{", "if", "(", "rs6000_stack_protector_guard", "==", "SSP_GLOBAL", ")", "return", "default_stack_protect_guard", "(", ")", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Only", "create", "the", "global", "variable", "for", "the", "stack", "protect", "guard", "if", "we", "are", "using", "the", "global", "flavor", "of", "that", "guard", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "bool", "rs6000_const_not_ok_for_debug_p", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", ")", "{", "rtx", "c", "=", "get_pool_constant", "(", "x", ")", ";", "machine_mode", "cmode", "=", "get_pool_mode", "(", "x", ")", ";", "if", "(", "ASM_OUTPUT_SPECIAL_POOL_ENTRY_P", "(", "c", ",", "cmode", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "should", "n't", "be", "emitted", "into", "the", "debug", "info", ".", "The", "linker", "does", "n't", "like", ".toc", "section", "references", "from", ".debug_", "*", "sections", ",", "so", "reject", ".toc", "section", "symbols", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "ARMFrameLowering", "::", "enableShrinkWrapping", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "STI", ".", "hasV8_1MMainlineOps", "(", ")", "&&", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "isCmseNSEntryFunction", "(", ")", ")", "return", "false", ";", "if", "(", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "shouldSignReturnAddress", "(", "true", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "will", "correctly", "handle", "shrink", "wrapping", "." ]

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

[]

[ "<s>", "unsigned", "Emitter", "<", "CodeEmitter", ">", "::", "getMachineOpValue", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "MO", ")", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "ARMRegisterInfo", "::", "getRegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "emitGlobalAddress", "(", "MO", ".", "getGlobal", "(", ")", ",", "ARM", "::", "reloc_arm_branch", ",", "true", ",", "false", ")", ";", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "emitExternalSymbolAddress", "(", "MO", ".", "getSymbolName", "(", ")", ",", "ARM", "::", "reloc_arm_branch", ")", ";", "else", "if", "(", "MO", ".", "isCPI", "(", ")", ")", "{", "const", "TargetInstrDesc", "&", "TID", "=", "MI", ".", "getDesc", "(", ")", ";", "unsigned", "Reloc", "=", "(", "(", "TID", ".", "TSFlags", "&", "ARMII", "::", "FormMask", ")", "==", "ARMII", "::", "VFPLdStFrm", ")", "?", "ARM", "::", "reloc_arm_vfp_cp_entry", ":", "ARM", "::", "reloc_arm_cp_entry", ";", "emitConstPoolAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "Reloc", ")", ";", "}", "else", "if", "(", "MO", ".", "isJTI", "(", ")", ")", "emitJumpTableAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "ARM", "::", "reloc_arm_relative", ")", ";", "else", "if", "(", "MO", ".", "isMBB", "(", ")", ")", "emitMachineBasicBlock", "(", "MO", ".", "getMBB", "(", ")", ",", "ARM", "::", "reloc_arm_branch", ")", ";", "else", "{", "cerr", "<<", "MO", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "ARM", "ARM", "ARM::reloc_arm_branch", "ARM::reloc_arm_branch", "ARMII::FormMask", "ARMII::VFPLdStFrm", "ARM::reloc_arm_vfp_cp_entry", "ARM::reloc_arm_cp_entry", "ARM::reloc_arm_relative", "ARM::reloc_arm_branch", "0", "0" ]

[]

[ "<s>", "rtx", "aarch64_atomic_ool_func", "(", "machine_mode", "mode", ",", "rtx", "model_rtx", ",", "const", "atomic_ool_names", "*", "names", ")", "{", "memmodel", "model", "=", "memmodel_base", "(", "INTVAL", "(", "model_rtx", ")", ")", ";", "int", "mode_idx", ",", "model_idx", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "mode_idx", "=", "0", ";", "break", ";", "case", "E_HImode", ":", "mode_idx", "=", "1", ";", "break", ";", "case", "E_SImode", ":", "mode_idx", "=", "2", ";", "break", ";", "case", "E_DImode", ":", "mode_idx", "=", "3", ";", "break", ";", "case", "E_TImode", ":", "mode_idx", "=", "4", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "model", ")", "{", "case", "MEMMODEL_RELAXED", ":", "model_idx", "=", "0", ";", "break", ";", "case", "MEMMODEL_CONSUME", ":", "case", "MEMMODEL_ACQUIRE", ":", "model_idx", "=", "1", ";", "break", ";", "case", "MEMMODEL_RELEASE", ":", "model_idx", "=", "2", ";", "break", ";", "case", "MEMMODEL_ACQ_REL", ":", "case", "MEMMODEL_SEQ_CST", ":", "model_idx", "=", "3", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "init_one_libfunc_visibility", "(", "names", "->", "str", "[", "mode_idx", "]", "[", "model_idx", "]", ",", "VISIBILITY_HIDDEN", ")", ";", "}", "</s>" ]

[ "We", "store", "the", "names", "of", "the", "various", "atomic", "helpers", "in", "a", "5x4", "array", ".", "Return", "the", "libcall", "function", "given", "MODE", ",", "MODEL", "and", "NAMES", "." ]

[ "aarch64", "0", "1", "2", "3", "4", "0", "1", "2", "3" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "llvm_unreachable", "(", "\"RelaxInstruction() unimplemented\"", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "P2", "\"RelaxInstruction() unimplemented\"" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isPredicable", "(", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "!", "MI", ".", "isPredicable", "(", ")", ")", "return", "false", ";", "if", "(", "!", "isEligibleForITBlock", "(", "&", "MI", ")", ")", "return", "false", ";", "ARMFunctionInfo", "*", "AFI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "AFI", "->", "isThumb2Function", "(", ")", ")", "{", "if", "(", "getSubtarget", "(", ")", ".", "restrictIT", "(", ")", ")", "return", "isV8EligibleForIT", "(", "&", "MI", ")", ";", "}", "else", "{", "if", "(", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ")", "==", "ARMII", "::", "DomainNEON", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARMII::DomainMask", "ARMII::DomainNEON" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected Kind in getPointerRegClass!\"", ")", ";", "case", "0", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", ")", "return", "&", "X86", "::", "GR64RegClass", ";", "return", "&", "X86", "::", "GR32RegClass", ";", "case", "1", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOSPRegClass", ";", "return", "&", "X86", "::", "GR32_NOSPRegClass", ";", "case", "2", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOREXRegClass", ";", "return", "&", "X86", "::", "GR32_NOREXRegClass", ";", "case", "3", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOREX_NOSPRegClass", ";", "return", "&", "X86", "::", "GR32_NOREX_NOSPRegClass", ";", "case", "4", ":", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "IsWin64", "||", "(", "F", "&&", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "X86_64_Win64", ")", ")", "return", "&", "X86", "::", "GR64_TCW64RegClass", ";", "else", "if", "(", "Is64Bit", ")", "return", "&", "X86", "::", "GR64_TCRegClass", ";", "bool", "hasHipeCC", "=", "(", "F", "?", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "HiPE", ":", "false", ")", ";", "if", "(", "hasHipeCC", ")", "return", "&", "X86", "::", "GR32RegClass", ";", "return", "&", "X86", "::", "GR32_TCRegClass", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"Unexpected Kind in getPointerRegClass!\"", "0", "X86::GR64RegClass", "X86::GR32RegClass", "1", "X86::GR64_NOSPRegClass", "X86::GR32_NOSPRegClass", "2", "X86::GR64_NOREXRegClass", "X86::GR32_NOREXRegClass", "3", "X86::GR64_NOREX_NOSPRegClass", "X86::GR32_NOREX_NOSPRegClass", "4", "X86", "X86::GR64_TCW64RegClass", "X86::GR64_TCRegClass", "X86::GR32RegClass", "X86::GR32_TCRegClass" ]

[]

[ "<s>", "void", "BTFDebug", "::", "beginFunctionImpl", "(", "const", "MachineFunction", "*", "MF", ")", "{", "auto", "*", "SP", "=", "MF", "->", "getFunction", "(", ")", ".", "getSubprogram", "(", ")", ";", "auto", "*", "Unit", "=", "SP", "->", "getUnit", "(", ")", ";", "if", "(", "Unit", "->", "getEmissionKind", "(", ")", "==", "DICompileUnit", "::", "NoDebug", ")", "{", "SkipInstruction", "=", "true", ";", "return", ";", "}", "SkipInstruction", "=", "false", ";", "if", "(", "MapDefNotCollected", ")", "{", "processGlobals", "(", "true", ")", ";", "MapDefNotCollected", "=", "false", ";", "}", "std", "::", "unordered_map", "<", "uint32_t", ",", "StringRef", ">", "FuncArgNames", ";", "for", "(", "const", "DINode", "*", "DN", ":", "SP", "->", "getRetainedNodes", "(", ")", ")", "{", "if", "(", "const", "auto", "*", "DV", "=", "dyn_cast", "<", "DILocalVariable", ">", "(", "DN", ")", ")", "{", "uint32_t", "Arg", "=", "DV", "->", "getArg", "(", ")", ";", "if", "(", "Arg", ")", "{", "visitTypeEntry", "(", "DV", "->", "getType", "(", ")", ")", ";", "FuncArgNames", "[", "Arg", "]", "=", "DV", "->", "getName", "(", ")", ";", "}", "}", "}", "uint32_t", "ProtoTypeId", ";", "visitSubroutineType", "(", "SP", "->", "getType", "(", ")", ",", "true", ",", "FuncArgNames", ",", "ProtoTypeId", ")", ";", "auto", "FuncTypeEntry", "=", "std", "::", "make_unique", "<", "BTFTypeFunc", ">", "(", "SP", "->", "getName", "(", ")", ",", "ProtoTypeId", ")", ";", "uint32_t", "FuncTypeId", "=", "addType", "(", "std", "::", "move", "(", "FuncTypeEntry", ")", ")", ";", "for", "(", "const", "auto", "&", "TypeEntry", ":", "TypeEntries", ")", "TypeEntry", "->", "completeType", "(", "*", "this", ")", ";", "MCSymbol", "*", "FuncLabel", "=", "Asm", "->", "getFunctionBegin", "(", ")", ";", "BTFFuncInfo", "FuncInfo", ";", "FuncInfo", ".", "Label", "=", "FuncLabel", ";", "FuncInfo", ".", "TypeId", "=", "FuncTypeId", ";", "if", "(", "FuncLabel", "->", "isInSection", "(", ")", ")", "{", "MCSection", "&", "Section", "=", "FuncLabel", "->", "getSection", "(", ")", ";", "const", "MCSectionELF", "*", "SectionELF", "=", "dyn_cast", "<", "MCSectionELF", ">", "(", "&", "Section", ")", ";", "assert", "(", "SectionELF", "&&", "\"Null section for Function Label\"", ")", ";", "SecNameOff", "=", "addString", "(", "SectionELF", "->", "getSectionName", "(", ")", ")", ";", "}", "else", "{", "SecNameOff", "=", "addString", "(", "\".text\"", ")", ";", "}", "FuncInfoTable", "[", "SecNameOff", "]", ".", "push_back", "(", "FuncInfo", ")", ";", "}", "</s>" ]

[ "Gather", "pre-function", "debug", "information", "." ]

[ "BPF", "\"Null section for Function Label\"", "\".text\"" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "X86", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"reloc_riprel_4byte\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_riprel_4byte_movq_load\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_riprel_4byte_relax\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_riprel_4byte_relax_rex\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_signed_4byte\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"reloc_global_offset_table\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"reloc_global_offset_table8\"", ",", "0", ",", "64", ",", "0", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "X86", "X86::NumTargetFixupKinds", "\"reloc_riprel_4byte\"", "0", "32", "\"reloc_riprel_4byte_movq_load\"", "0", "32", "\"reloc_riprel_4byte_relax\"", "0", "32", "\"reloc_riprel_4byte_relax_rex\"", "0", "32", "\"reloc_signed_4byte\"", "0", "32", "0", "\"reloc_global_offset_table\"", "0", "32", "0", "\"reloc_global_offset_table8\"", "0", "64", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "const", "ARMSubtarget", "*", "ARMBaseTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "bool", "SoftFloat", "=", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ";", "if", "(", "SoftFloat", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\",+soft-float\"", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "ARMSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ")", ";", "GISelAccessor", "*", "GISel", "=", "new", "GISelAccessor", "(", ")", ";", "ARMGISelActualAccessor", "*", "GISel", "=", "new", "ARMGISelActualAccessor", "(", ")", ";", "GISel", "->", "CallLoweringInfo", ".", "reset", "(", "new", "ARMCallLowering", "(", "*", "I", "->", "getTargetLowering", "(", ")", ")", ")", ";", "GISel", "->", "Legalizer", ".", "reset", "(", "new", "ARMLegalizerInfo", "(", "*", "I", ")", ")", ";", "auto", "*", "RBI", "=", "new", "ARMRegisterBankInfo", "(", "*", "I", "->", "getRegisterInfo", "(", ")", ")", ";", "GISel", "->", "InstSelector", ".", "reset", "(", "createARMInstructionSelector", "(", "*", "this", ",", "*", "I", ",", "*", "RBI", ")", ")", ";", "GISel", "->", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "I", "->", "setGISelAccessor", "(", "*", "GISel", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "ARM", "ARM", "ARM", "\"target-cpu\"", "\"target-features\"", "\"use-soft-float\"", "\"true\"", "\"+soft-float\"", "\",+soft-float\"", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "static", "void", "push_minipool_fix", "(", "rtx_insn", "*", "insn", ",", "HOST_WIDE_INT", "address", ",", "rtx", "*", "loc", ",", "machine_mode", "mode", ",", "rtx", "value", ")", "{", "Mfix", "*", "fix", "=", "(", "Mfix", "*", ")", "obstack_alloc", "(", "&", "minipool_obstack", ",", "sizeof", "(", "*", "fix", ")", ")", ";", "fix", "->", "insn", "=", "insn", ";", "fix", "->", "address", "=", "address", ";", "fix", "->", "loc", "=", "loc", ";", "fix", "->", "mode", "=", "mode", ";", "fix", "->", "fix_size", "=", "MINIPOOL_FIX_SIZE", "(", "mode", ")", ";", "fix", "->", "value", "=", "value", ";", "fix", "->", "forwards", "=", "get_attr_pool_range", "(", "insn", ")", ";", "fix", "->", "backwards", "=", "get_attr_neg_pool_range", "(", "insn", ")", ";", "fix", "->", "minipool", "=", "NULL", ";", "gcc_assert", "(", "fix", "->", "forwards", "||", "fix", "->", "backwards", ")", ";", "if", "(", "ARM_DOUBLEWORD_ALIGN", "&&", "fix", "->", "fix_size", ">=", "8", ")", "minipool_pad", "=", "4", ";", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\";; %smode fixup for i%d; addr %lu, range (%ld,%ld): \"", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "INSN_UID", "(", "insn", ")", ",", "(", "unsigned", "long", ")", "address", ",", "-", "1", "*", "(", "long", ")", "fix", "->", "backwards", ",", "(", "long", ")", "fix", "->", "forwards", ")", ";", "arm_print_value", "(", "dump_file", ",", "fix", "->", "value", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\n\"", ")", ";", "}", "fix", "->", "next", "=", "NULL", ";", "if", "(", "minipool_fix_head", "!=", "NULL", ")", "minipool_fix_tail", "->", "next", "=", "fix", ";", "else", "minipool_fix_head", "=", "fix", ";", "minipool_fix_tail", "=", "fix", ";", "}", "</s>" ]

[ "Record", "INSN", ",", "which", "will", "need", "fixing", "up", "to", "load", "a", "value", "from", "the", "minipool", ".", "ADDRESS", "is", "the", "offset", "of", "the", "insn", "since", "the", "start", "of", "the", "function", ";", "LOC", "is", "a", "pointer", "to", "the", "part", "of", "the", "insn", "which", "requires", "fixing", ";", "VALUE", "is", "the", "constant", "that", "must", "be", "loaded", ",", "which", "is", "of", "type", "MODE", "." ]

[ "arm", "8", "4", "\";; %smode fixup for i%d; addr %lu, range (%ld,%ld): \"", "1", "\"\\n\"" ]

[]

[ "<s>", "bool", "PadShortFunc", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "AttributeSet", "&", "FnAttrs", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ";", "if", "(", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeForSize", ")", "||", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "MinSize", ")", ")", "{", "return", "false", ";", "}", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "STI", "->", "padShortFunctions", "(", ")", ")", "return", "false", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "ReturnBBs", ".", "clear", "(", ")", ";", "VisitedBBs", ".", "clear", "(", ")", ";", "findReturns", "(", "MF", ".", "begin", "(", ")", ")", ";", "bool", "MadeChange", "=", "false", ";", "MachineBasicBlock", "*", "MBB", ";", "unsigned", "int", "Cycles", "=", "0", ";", "for", "(", "DenseMap", "<", "MachineBasicBlock", "*", ",", "unsigned", "int", ">", "::", "iterator", "I", "=", "ReturnBBs", ".", "begin", "(", ")", ";", "I", "!=", "ReturnBBs", ".", "end", "(", ")", ";", "++", "I", ")", "{", "MBB", "=", "I", "->", "first", ";", "Cycles", "=", "I", "->", "second", ";", "if", "(", "Cycles", "<", "Threshold", ")", "{", "assert", "(", "MBB", "->", "size", "(", ")", ">", "0", "&&", "\"Basic block should contain at least a RET but is empty\"", ")", ";", "MachineBasicBlock", "::", "iterator", "ReturnLoc", "=", "--", "MBB", "->", "end", "(", ")", ";", "while", "(", "ReturnLoc", "->", "isDebugValue", "(", ")", ")", "--", "ReturnLoc", ";", "assert", "(", "ReturnLoc", "->", "isReturn", "(", ")", "&&", "!", "ReturnLoc", "->", "isCall", "(", ")", "&&", "\"Basic block does not end with RET\"", ")", ";", "addPadding", "(", "MBB", ",", "ReturnLoc", ",", "Threshold", "-", "Cycles", ")", ";", "NumBBsPadded", "++", ";", "MadeChange", "=", "true", ";", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "0", "\"Basic block should contain at least a RET but is empty\"", "\"Basic block does not end with RET\"" ]

[]

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

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

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

[]

[ "<s>", "bool", "SIFixWWMLiveness", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Modified", "=", "false", ";", "LIS", "=", "getAnalysisIfAvailable", "<", "LiveIntervals", ">", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "EXIT_WWM", ")", "{", "Modified", "|=", "runOnWWMInstruction", "(", "MI", ")", ";", "}", "}", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "AMDGPU::EXIT_WWM" ]

[]

[ "<s>", "TargetIRAnalysis", "MipsTargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "Function", "&", "F", ")", "{", "if", "(", "Subtarget", "->", "allowMixed16_32", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"No Target Transform Info Pass Added\\n\"", ")", ";", "return", "TargetTransformInfo", "(", "getDataLayout", "(", ")", ")", ";", "}", "DEBUG", "(", "errs", "(", ")", "<<", "\"Target Transform Info Pass Added\\n\"", ")", ";", "return", "TargetTransformInfo", "(", "BasicTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetIRAnalysis", "appropriate", "for", "the", "target", "." ]

[ "Mips", "Mips", "\"No Target Transform Info Pass Added\\n\"", "\"Target Transform Info Pass Added\\n\"" ]

[]