Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "SparcTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "APInt", "&", "KnownZero", ",", "APInt", "&", "KnownOne", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "APInt", "KnownZero2", ",", "KnownOne2", ";", "KnownZero", "=", "KnownOne", "=", "APInt", "(", "KnownZero", ".", "getBitWidth", "(", ")", ",", "0", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "SPISD", "::", "SELECT_ICC", ":", "case", "SPISD", "::", "SELECT_XCC", ":", "case", "SPISD", "::", "SELECT_FCC", ":", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "KnownZero", ",", "KnownOne", ",", "Depth", "+", "1", ")", ";", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "KnownZero2", ",", "KnownOne2", ",", "Depth", "+", "1", ")", ";", "KnownOne", "&=", "KnownOne2", ";", "KnownZero", "&=", "KnownZero2", ";", "break", ";", "}", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "Sparc", "Sparc", "0", "SPISD::SELECT_ICC", "SPISD::SELECT_XCC", "SPISD::SELECT_FCC", "1", "1", "0", "1" ]

[]

[ "<s>", "TargetIRAnalysis", "AArch64TargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "AArch64TTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "MipsSubtarget", "*", "MipsTargetMachine", "::", "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", "hasMips16Attr", "=", "!", "F", ".", "getFnAttribute", "(", "\"mips16\"", ")", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", ";", "bool", "hasNoMips16Attr", "=", "!", "F", ".", "getFnAttribute", "(", "\"nomips16\"", ")", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", ";", "Attribute", "SFAttr", "=", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ";", "bool", "softFloat", "=", "!", "SFAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "SFAttr", ".", "getValueAsString", "(", ")", "==", "\"true\"", ":", "Options", ".", "UseSoftFloat", ";", "if", "(", "hasMips16Attr", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "\"+mips16\"", ":", "\",+mips16\"", ";", "else", "if", "(", "hasNoMips16Attr", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "\"-mips16\"", ":", "\",-mips16\"", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "+", "(", "softFloat", "?", "\"use-soft-float=true\"", ":", "\"use-soft-float=false\"", ")", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "MipsSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "isLittle", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "\"target-cpu\"", "\"target-features\"", "Mips", "\"mips16\"", "Mips", "\"nomips16\"", "\"use-soft-float\"", "\"true\"", "Mips", "\"+mips16\"", "\",+mips16\"", "Mips", "\"-mips16\"", "\",-mips16\"", "\"use-soft-float=true\"", "\"use-soft-float=false\"", "Mips" ]

[]

[ "<s>", "const", "char", "*", "WebAssemblyAsmPrinter", "::", "toString", "(", "Type", "*", "Ty", ")", "const", "{", "switch", "(", "Ty", "->", "getTypeID", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Type", "::", "PointerTyID", ":", "switch", "(", "getPointerSize", "(", ")", ")", "{", "case", "4", ":", "return", "\"i32\"", ";", "case", "8", ":", "return", "\"i64\"", ";", "default", ":", "llvm_unreachable", "(", "\"unsupported pointer size\"", ")", ";", "}", "break", ";", "case", "Type", "::", "FloatTyID", ":", "return", "\"f32\"", ";", "case", "Type", "::", "DoubleTyID", ":", "return", "\"f64\"", ";", "case", "Type", "::", "IntegerTyID", ":", "switch", "(", "Ty", "->", "getIntegerBitWidth", "(", ")", ")", "{", "case", "8", ":", "return", "\"i8\"", ";", "case", "16", ":", "return", "\"i16\"", ";", "case", "32", ":", "return", "\"i32\"", ";", "case", "64", ":", "return", "\"i64\"", ";", "default", ":", "break", ";", "}", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Invalid type \"", ";", "Ty", "->", "print", "(", "dbgs", "(", ")", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ")", ";", "llvm_unreachable", "(", "\"invalid type\"", ")", ";", "return", "\"<invalid>\"", ";", "}", "</s>" ]

[ "Convert", "to", "a", "decimal", "representation", "in", "a", "string", "." ]

[ "WebAssembly", "WebAssembly", "4", "\"i32\"", "8", "\"i64\"", "\"unsupported pointer size\"", "\"f32\"", "\"f64\"", "8", "\"i8\"", "16", "\"i16\"", "32", "\"i32\"", "64", "\"i64\"", "\"Invalid type \"", "\"invalid type\"", "\"<invalid>\"" ]

[]

[ "<s>", "bool", "AArch64CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "ArrayRef", "<", "Register", ">>", "VRegs", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "unsigned", "i", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "isa", "<", "ScalableVectorType", ">", "(", "Arg", ".", "getType", "(", ")", ")", ")", "return", "false", ";", "if", "(", "DL", ".", "getTypeStoreSize", "(", "Arg", ".", "getType", "(", ")", ")", ".", "isZero", "(", ")", ")", "continue", ";", "ArgInfo", "OrigArg", "{", "VRegs", "[", "i", "]", ",", "Arg", ".", "getType", "(", ")", "}", ";", "setArgFlags", "(", "OrigArg", ",", "i", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "F", ".", "getCallingConv", "(", ")", ")", ";", "++", "i", ";", "}", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ")", ";", "FormalArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "AssignFn", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "AArch64FunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "uint64_t", "StackOffset", "=", "Handler", ".", "StackUsed", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "{", "auto", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "{", "return", "false", ";", "}", "StackOffset", "=", "alignTo", "(", "Handler", ".", "StackUsed", ",", "Subtarget", ".", "isTargetILP32", "(", ")", "?", "4", ":", "8", ")", ";", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "FuncInfo", "->", "setVarArgsStackIndex", "(", "MFI", ".", "CreateFixedObject", "(", "4", ",", "StackOffset", ",", "true", ")", ")", ";", "}", "if", "(", "doesCalleeRestoreStack", "(", "F", ".", "getCallingConv", "(", ")", ",", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", ")", ")", "{", "StackOffset", "=", "alignTo", "(", "StackOffset", ",", "16", ")", ";", "FuncInfo", "->", "setArgumentStackToRestore", "(", "StackOffset", ")", ";", "}", "FuncInfo", "->", "setBytesInStackArgArea", "(", "StackOffset", ")", ";", "auto", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "hasCustomCallingConv", "(", ")", ")", "Subtarget", ".", "getRegisterInfo", "(", ")", "->", "UpdateCustomCalleeSavedRegs", "(", "MF", ")", ";", "handleMustTailForwardedRegisters", "(", "MIRBuilder", ",", "AssignFn", ")", ";", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "AArch64", "AArch64", "8", "0", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "4", "8", "4", "16", "AArch64" ]

[]

[ "<s>", "std", "::", "string", "MBlazeIntrinsicInfo", "::", "getName", "(", "unsigned", "IntrID", ",", "Type", "*", "*", "Tys", ",", "unsigned", "numTys", ")", "const", "{", "static", "const", "char", "*", "const", "names", "[", "]", "=", "{", "}", ";", "assert", "(", "!", "isOverloaded", "(", "IntrID", ")", "&&", "\"MBlaze intrinsics are not overloaded\"", ")", ";", "if", "(", "IntrID", "<", "Intrinsic", "::", "num_intrinsics", ")", "return", "0", ";", "assert", "(", "IntrID", "<", "mblazeIntrinsic", "::", "num_mblaze_intrinsics", "&&", "\"Invalid intrinsic ID\"", ")", ";", "std", "::", "string", "Result", "(", "names", "[", "IntrID", "-", "Intrinsic", "::", "num_intrinsics", "]", ")", ";", "return", "Result", ";", "}", "</s>" ]

[ "Return", "a", "string", "with", "the", "name", "of", "the", "plan", "and", "the", "applicable", "VFs", "and", "UFs", "." ]

[ "MBlaze", "MBlaze", "\"MBlaze intrinsics are not overloaded\"", "Intrinsic::num_intrinsics", "0", "mblazeIntrinsic::num_mblaze_intrinsics", "\"Invalid intrinsic ID\"", "Intrinsic::num_intrinsics" ]

[]

[ "<s>", "static", "bool", "set_to_load_agen", "(", "rtx_insn", "*", "out_insn", ",", "rtx_insn", "*", "in_insn", ")", "{", "rtx", "out_set", ",", "in_set", ";", "out_set", "=", "single_set", "(", "out_insn", ")", ";", "if", "(", "out_set", ")", "{", "in_set", "=", "single_set", "(", "in_insn", ")", ";", "if", "(", "in_set", ")", "return", "reg_mentioned_p", "(", "SET_DEST", "(", "out_set", ")", ",", "SET_SRC", "(", "in_set", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "The", "function", "returns", "true", "if", "out_inst", "sets", "a", "value", "that", "is", "used", "in", "the", "address", "generation", "computation", "of", "in_insn" ]

[ "powerpcspe" ]

[]

[ "<s>", "EVT", "SITargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", "Ctx", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "{", "return", "MVT", "::", "i1", ";", "}", "return", "EVT", "::", "getVectorVT", "(", "Ctx", ",", "MVT", "::", "i1", ",", "VT", ".", "getVectorNumElements", "(", ")", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "MVT::i1", "MVT::i1" ]

[]

[ "<s>", "static", "void", "handle_attr_preserve", "(", "function", "*", "fn", ")", "{", "basic_block", "bb", ";", "rtx_insn", "*", "insn", ";", "FOR_EACH_BB_FN", "(", "bb", ",", "fn", ")", "{", "FOR_BB_INSNS", "(", "bb", ",", "insn", ")", "{", "if", "(", "!", "NONJUMP_INSN_P", "(", "insn", ")", ")", "continue", ";", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", ")", "continue", ";", "start_sequence", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "2", ";", "i", "++", ")", "{", "rtx", "mem", "=", "XEXP", "(", "pat", ",", "i", ")", ";", "if", "(", "MEM_P", "(", "mem", ")", ")", "{", "tree", "expr", "=", "MEM_EXPR", "(", "mem", ")", ";", "if", "(", "!", "expr", ")", "continue", ";", "if", "(", "TREE_CODE", "(", "expr", ")", "==", "MEM_REF", "&&", "TREE_CODE", "(", "TREE_OPERAND", "(", "expr", ",", "0", ")", ")", "==", "SSA_NAME", ")", "{", "gimple", "*", "def_stmt", "=", "SSA_NAME_DEF_STMT", "(", "TREE_OPERAND", "(", "expr", ",", "0", ")", ")", ";", "if", "(", "def_stmt", "&&", "is_gimple_assign", "(", "def_stmt", ")", ")", "expr", "=", "gimple_assign_rhs1", "(", "def_stmt", ")", ";", "}", "if", "(", "is_attr_preserve_access", "(", "expr", ")", ")", "maybe_make_core_relo", "(", "expr", ",", "BPF_RELO_FIELD_BYTE_OFFSET", ")", ";", "}", "}", "rtx_insn", "*", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_insn_before", "(", "seq", ",", "insn", ")", ";", "}", "}", "}", "</s>" ]

[ "The", "body", "of", "pass_bpf_core_attr", ".", "Scan", "RTL", "for", "accesses", "to", "structs/unions", "marked", "with", "__attribute__", "(", "(", "preserve_access_index", ")", ")", "and", "generate", "a", "CO-RE", "relocation", "for", "any", "such", "access", "." ]

[ "bpf", "0", "2", "0", "0" ]

[]

[ "<s>", "static", "bool", "tilegx_legitimate_address_p", "(", "machine_mode", "ARG_UNUSED", "(", "mode", ")", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "POST_INC", ":", "case", "POST_DEC", ":", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ">", "UNITS_PER_WORD", ")", "return", "false", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "break", ";", "case", "POST_MODIFY", ":", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ">", "UNITS_PER_WORD", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "PLUS", ")", "return", "false", ";", "if", "(", "!", "rtx_equal_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ")", ")", "return", "false", ";", "if", "(", "!", "satisfies_constraint_I", "(", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "1", ")", ")", ")", "return", "false", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "break", ";", "case", "REG", ":", "break", ";", "default", ":", "return", "false", ";", "}", "if", "(", "!", "REG_P", "(", "x", ")", ")", "return", "false", ";", "if", "(", "strict", ")", "return", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "x", ")", ")", ";", "else", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "rtx", "X", "can", "be", "used", "as", "an", "address", "operand", "." ]

[ "tilegx", "0", "1", "0", "1", "0", "1", "1", "0" ]

[]

[ "<s>", "static", "rtx", "riscv_pass_fpr_pair", "(", "machine_mode", "mode", ",", "unsigned", "regno1", ",", "machine_mode", "mode1", ",", "HOST_WIDE_INT", "offset1", ",", "unsigned", "regno2", ",", "machine_mode", "mode2", ",", "HOST_WIDE_INT", "offset2", ")", "{", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode1", ",", "regno1", ")", ",", "GEN_INT", "(", "offset1", ")", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode2", ",", "regno2", ")", ",", "GEN_INT", "(", "offset2", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Pass", "or", "return", "a", "composite", "value", "in", "the", "FPR", "pair", "REGNO", "and", "REGNO", "+", "1", ".", "MODE", "is", "the", "mode", "of", "the", "composite", ".", "MODE1", "and", "OFFSET1", "are", "the", "mode", "and", "byte", "offset", "for", "the", "first", "value", ",", "likewise", "MODE2", "and", "OFFSET2", "for", "the", "second", "value", "." ]

[ "riscv", "2" ]

[]

[ "<s>", "void", "ARMElfTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "const", "ARMBaseTargetMachine", "&", "ARM_TM", "=", "static_cast", "<", "const", "ARMBaseTargetMachine", "&", ">", "(", "TM", ")", ";", "bool", "isAAPCS_ABI", "=", "ARM_TM", ".", "TargetABI", "==", "ARMBaseTargetMachine", "::", "ARMABI", "::", "ARM_ABI_AAPCS", ";", "bool", "genExecuteOnly", "=", "ARM_TM", ".", "getMCSubtargetInfo", "(", ")", "->", "hasFeature", "(", "ARM", "::", "FeatureExecuteOnly", ")", ";", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "isAAPCS_ABI", ")", ";", "if", "(", "isAAPCS_ABI", ")", "{", "LSDASection", "=", "nullptr", ";", "}", "if", "(", "genExecuteOnly", ")", "{", "unsigned", "Type", "=", "ELF", "::", "SHT_PROGBITS", ";", "unsigned", "Flags", "=", "ELF", "::", "SHF_EXECINSTR", "|", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_ARM_PURECODE", ";", "TextSection", "=", "Ctx", ".", "getELFSection", "(", "\".text\"", ",", "Type", ",", "Flags", ",", "0", ",", "\"\"", ",", "0U", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARMABI::ARM_ABI_AAPCS", "ARM", "ARM::FeatureExecuteOnly", "ARM", "\".text\"", "0", "\"\"", "0U" ]

[]

[ "<s>", "rtx", "get_avl_type_rtx", "(", "enum", "avl_type", "type", ")", "{", "return", "gen_int_mode", "(", "type", ",", "Pmode", ")", ";", "}", "</s>" ]

[ "Get", "avl_type", "rtx", "." ]

[ "riscv" ]

[]

[ "<s>", "rtx", "resolve_reload_operand", "(", "rtx", "op", ")", "{", "if", "(", "reload_in_progress", ")", "{", "rtx", "tmp", "=", "op", ";", "if", "(", "SUBREG_P", "(", "tmp", ")", ")", "tmp", "=", "SUBREG_REG", "(", "tmp", ")", ";", "if", "(", "REG_P", "(", "tmp", ")", "&&", "REGNO", "(", "tmp", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", "{", "op", "=", "reg_equiv_memory_loc", "(", "REGNO", "(", "tmp", ")", ")", ";", "if", "(", "op", "==", "0", ")", "return", "0", ";", "}", "}", "return", "op", ";", "}", "</s>" ]

[ "Used", "by", "aligned_memory_operand", "and", "unaligned_memory_operand", "to", "resolve", "what", "reload", "is", "going", "to", "do", "with", "OP", "if", "it", "'s", "a", "register", "." ]

[ "alpha", "0", "0" ]

[]

[ "<s>", "MCFragment", "*", "findAssociatedFragment", "(", ")", "const", "override", "{", "return", "getSubExpr", "(", ")", "->", "findAssociatedFragment", "(", ")", ";", "}", "</s>" ]

[ "Find", "the", "``", "associated", "section", "''", "for", "this", "expression", ",", "which", "is", "currently", "defined", "as", "the", "absolute", "section", "for", "constants", ",", "or", "otherwise", "the", "section", "associated", "with", "the", "first", "defined", "symbol", "in", "the", "expression", "." ]

[ "MCS51" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "isPredicated", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "already", "predicated", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "isSourceOfDivergence", "(", "const", "Value", "*", "V", ")", "const", "{", "if", "(", "const", "Argument", "*", "A", "=", "dyn_cast", "<", "Argument", ">", "(", "V", ")", ")", "return", "!", "isArgPassedInSGPR", "(", "A", ")", ";", "if", "(", "const", "LoadInst", "*", "Load", "=", "dyn_cast", "<", "LoadInst", ">", "(", "V", ")", ")", "return", "Load", "->", "getPointerAddressSpace", "(", ")", "==", "ST", "->", "getAMDGPUAS", "(", ")", ".", "PRIVATE_ADDRESS", ";", "if", "(", "isa", "<", "AtomicRMWInst", ">", "(", "V", ")", "||", "isa", "<", "AtomicCmpXchgInst", ">", "(", "V", ")", ")", "return", "true", ";", "if", "(", "const", "IntrinsicInst", "*", "Intrinsic", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "V", ")", ")", "return", "AMDGPU", "::", "isIntrinsicSourceOfDivergence", "(", "Intrinsic", "->", "getIntrinsicID", "(", ")", ")", ";", "if", "(", "isa", "<", "CallInst", ">", "(", "V", ")", "||", "isa", "<", "InvokeInst", ">", "(", "V", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "whether", "V", "is", "a", "source", "of", "divergence", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::isIntrinsicSourceOfDivergence" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "materializeFrameBaseRegister", "(", "MachineBasicBlock", "*", "MBB", ",", "unsigned", "BaseReg", ",", "int", "FrameIdx", ",", "int64_t", "Offset", ")", "const", "{", "unsigned", "ADDriOpc", "=", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "ADDI8", ":", "PPC", "::", "ADDI", ";", "MachineBasicBlock", "::", "iterator", "Ins", "=", "MBB", "->", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "Ins", "!=", "MBB", "->", "end", "(", ")", ")", "DL", "=", "Ins", "->", "getDebugLoc", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", "->", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "TII", ".", "get", "(", "ADDriOpc", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "BaseReg", ",", "TII", ".", "getRegClass", "(", "MCID", ",", "0", ",", "this", ",", "MF", ")", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "MCID", ",", "BaseReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "Offset", ")", ";", "}", "</s>" ]

[ "Insert", "defining", "instruction", "(", "s", ")", "for", "a", "pointer", "to", "FrameIdx", "before", "insertion", "point", "I", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::ADDI8", "PPC::ADDI", "0" ]

[]

[ "<s>", "static", "rtx", "nds32_expand_builtin_load", "(", "enum", "insn_code", "icode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "nds32_read_argument", "(", "exp", ",", "0", ")", ";", "rtx", "addr_helper", "=", "gen_reg_rtx", "(", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "mode", ")", ";", "target", "=", "nds32_legitimize_target", "(", "icode", ",", "target", ")", ";", "op0", "=", "nds32_legitimize_argument", "(", "icode", ",", "1", ",", "op0", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ",", "addr_helper", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_move_insn", "(", "addr_helper", ",", "GEN_INT", "(", "0", ")", ")", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "builtins", "for", "load", "." ]

[ "nds32", "0", "1", "1", "0" ]

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "AMDGPUMCInstLower", "MCInstLowering", "(", "OutContext", ",", "MF", "->", "getTarget", "(", ")", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ")", ";", "StringRef", "Err", ";", "if", "(", "!", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", "->", "verifyInstruction", "(", "MI", ",", "Err", ")", ")", "{", "errs", "(", ")", "<<", "\"Warning: Illegal instruction detected: \"", "<<", "Err", "<<", "\"\\n\"", ";", "MI", "->", "dump", "(", ")", ";", "}", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", ";", "++", "I", ";", "while", "(", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", "{", "EmitInstruction", "(", "I", ")", ";", "++", "I", ";", "}", "}", "else", "{", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "TmpInst", ")", ";", "if", "(", "DisasmEnabled", ")", "{", "DisasmLines", ".", "resize", "(", "DisasmLines", ".", "size", "(", ")", "+", "1", ")", ";", "std", "::", "string", "&", "DisasmLine", "=", "DisasmLines", ".", "back", "(", ")", ";", "raw_string_ostream", "DisasmStream", "(", "DisasmLine", ")", ";", "AMDGPUInstPrinter", "InstPrinter", "(", "*", "TM", ".", "getMCAsmInfo", "(", ")", ",", "*", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ",", "*", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getRegisterInfo", "(", ")", ")", ";", "InstPrinter", ".", "printInst", "(", "&", "TmpInst", ",", "DisasmStream", ",", "StringRef", "(", ")", ")", ";", "SmallVector", "<", "MCFixup", ",", "4", ">", "Fixups", ";", "SmallVector", "<", "char", ",", "16", ">", "CodeBytes", ";", "raw_svector_ostream", "CodeStream", "(", "CodeBytes", ")", ";", "MCObjectStreamer", "&", "ObjStreamer", "=", "(", "MCObjectStreamer", "&", ")", "OutStreamer", ";", "MCCodeEmitter", "&", "InstEmitter", "=", "ObjStreamer", ".", "getAssembler", "(", ")", ".", "getEmitter", "(", ")", ";", "InstEmitter", ".", "EncodeInstruction", "(", "TmpInst", ",", "CodeStream", ",", "Fixups", ",", "TM", ".", "getSubtarget", "<", "MCSubtargetInfo", ">", "(", ")", ")", ";", "CodeStream", ".", "flush", "(", ")", ";", "HexLines", ".", "resize", "(", "HexLines", ".", "size", "(", ")", "+", "1", ")", ";", "std", "::", "string", "&", "HexLine", "=", "HexLines", ".", "back", "(", ")", ";", "raw_string_ostream", "HexStream", "(", "HexLine", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "CodeBytes", ".", "size", "(", ")", ";", "i", "+=", "4", ")", "{", "unsigned", "int", "CodeDWord", "=", "*", "(", "unsigned", "int", "*", ")", "&", "CodeBytes", "[", "i", "]", ";", "HexStream", "<<", "format", "(", "\"%s%08X\"", ",", "(", "i", ">", "0", "?", "\" \"", ":", "\"\"", ")", ",", "CodeDWord", ")", ";", "}", "DisasmStream", ".", "flush", "(", ")", ";", "DisasmLineMaxLen", "=", "std", "::", "max", "(", "DisasmLineMaxLen", ",", "DisasmLine", ".", "size", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "R600", "\"Warning: Illegal instruction detected: \"", "\"\\n\"", "1", "4", "16", "1", "0", "4", "\"%s%08X\"", "0", "\" \"", "\"\"" ]

[]

[ "<s>", "int", "pru_hard_regno_rename_ok", "(", "unsigned", "int", "old_reg", ",", "unsigned", "int", "new_reg", ")", "{", "if", "(", "(", "!", "reload_completed", "||", "frame_pointer_needed", ")", "&&", "(", "IN_RANGE", "(", "old_reg", ",", "HARD_FRAME_POINTER_REGNUM", ",", "HARD_FRAME_POINTER_REGNUM", "+", "3", ")", "||", "IN_RANGE", "(", "old_reg", ",", "FRAME_POINTER_REGNUM", ",", "FRAME_POINTER_REGNUM", "+", "3", ")", "||", "IN_RANGE", "(", "new_reg", ",", "HARD_FRAME_POINTER_REGNUM", ",", "HARD_FRAME_POINTER_REGNUM", "+", "3", ")", "||", "IN_RANGE", "(", "new_reg", ",", "FRAME_POINTER_REGNUM", ",", "FRAME_POINTER_REGNUM", "+", "3", ")", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Worker", "function", "for", "`", "HARD_REGNO_RENAME_OK", "'", ".", "Return", "nonzero", "if", "register", "OLD_REG", "can", "be", "renamed", "to", "register", "NEW_REG", "." ]

[ "pru", "3", "3", "3", "3", "0", "1" ]

[]

[ "<s>", "bool", "Z80oldInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ",", "UnCondBrIter", "=", "I", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "{", "continue", ";", "}", "if", "(", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "{", "break", ";", "}", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "{", "return", "true", ";", "}", "if", "(", "!", "I", "->", "getOperand", "(", "0", ")", ".", "isMBB", "(", ")", ")", "{", "return", "true", ";", "}", "if", "(", "I", "->", "getNumOperands", "(", ")", "==", "1", ")", "{", "UnCondBrIter", "=", "I", ";", "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", "(", ")", ";", "UnCondBrIter", "=", "I", ";", "continue", ";", "}", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "assert", "(", "I", "->", "getNumExplicitOperands", "(", ")", "==", "2", "&&", "\"Invalid conditional branch\"", ")", ";", "Z80old", "::", "CondCode", "BranchCode", "=", "Z80old", "::", "CondCode", "(", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "MachineBasicBlock", "*", "TargetBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "if", "(", "AllowModify", "&&", "UnCondBrIter", "!=", "MBB", ".", "end", "(", ")", "&&", "MBB", ".", "isLayoutSuccessor", "(", "TargetBB", ")", ")", "{", "BranchCode", "=", "GetOppositeBranchCondition", "(", "BranchCode", ")", ";", "MachineBasicBlock", "::", "iterator", "OldInst", "=", "I", ";", "BuildMI", "(", "MBB", ",", "UnCondBrIter", ",", "MBB", ".", "findDebugLoc", "(", "I", ")", ",", "get", "(", "Z80old", "::", "JQCC", ")", ")", ".", "addMBB", "(", "UnCondBrIter", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ".", "addImm", "(", "BranchCode", ")", ";", "BuildMI", "(", "MBB", ",", "UnCondBrIter", ",", "MBB", ".", "findDebugLoc", "(", "I", ")", ",", "get", "(", "Z80old", "::", "JQ", ")", ")", ".", "addMBB", "(", "TargetBB", ")", ";", "OldInst", "->", "eraseFromParent", "(", ")", ";", "UnCondBrIter", "->", "eraseFromParent", "(", ")", ";", "UnCondBrIter", "=", "MBB", ".", "end", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "continue", ";", "}", "FBB", "=", "TBB", ";", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "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", "." ]

[ "Z80old", "Z80old", "0", "1", "0", "0", "0", "2", "\"Invalid conditional branch\"", "Z80old::CondCode", "Z80old::CondCode", "1", "0", "Z80old::JQCC", "0", "Z80old::JQ", "0" ]

[]

[ "<s>", "void", "emit_hard_vlmax_vsetvl", "(", "machine_mode", "vmode", ",", "rtx", "vl", ")", "{", "unsigned", "int", "sew", "=", "get_sew", "(", "vmode", ")", ";", "emit_insn", "(", "gen_vsetvl", "(", "Pmode", ",", "vl", ",", "RVV_VLMAX", ",", "gen_int_mode", "(", "sew", ",", "Pmode", ")", ",", "gen_int_mode", "(", "get_vlmul", "(", "vmode", ")", ",", "Pmode", ")", ",", "const0_rtx", ",", "const0_rtx", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "vlmax", "vsetvl", "instruction", ".", "This", "should", "only", "be", "used", "when", "optimization", "is", "disabled", "or", "after", "vsetvl", "insertion", "pass", "." ]

[ "riscv" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"PTX FP Rounding Mode Pass\"", ";", "}", "</s>" ]

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

[ "PTX", "\"PTX FP Rounding Mode Pass\"" ]

[]

[ "<s>", "const", "NyuziRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "Nyuzi", "Nyuzi" ]

[]

[ "<s>", "void", "MipsRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ";", "errs", "(", ")", "<<", "\"<--------->\\n\"", "<<", "MI", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "uint64_t", "stackSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "int64_t", "spOffset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", "<<", "\"spOffset : \"", "<<", "spOffset", "<<", "\"\\n\"", "<<", "\"stackSize : \"", "<<", "stackSize", "<<", "\"\\n\"", "<<", "\"alignment : \"", "<<", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectAlignment", "(", "FrameIndex", ")", "<<", "\"\\n\"", ")", ";", "eliminateFI", "(", "MI", ",", "FIOperandNum", ",", "FrameIndex", ",", "stackSize", ",", "spOffset", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"spOffset : \"", "\"\\n\"", "\"stackSize : \"", "\"\\n\"", "\"alignment : \"", "\"\\n\"" ]

[]

[ "<s>", "static", "void", "alpha_align_insns", "(", "unsigned", "int", "max_align", ",", "rtx", "(", "*", "next_group", ")", "(", "rtx", ",", "int", "*", ",", "int", "*", ")", ",", "rtx", "(", "*", "next_nop", ")", "(", "int", "*", ")", ")", "{", "unsigned", "int", "align", ";", "int", "ofs", ";", "int", "prev_in_use", ",", "in_use", ",", "len", ",", "ldgp", ";", "rtx", "i", ",", "next", ";", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "if", "(", "align_functions", "<", "4", ")", "align", "=", "4", ";", "else", "if", "(", "(", "unsigned", "int", ")", "align_functions", "<", "max_align", ")", "align", "=", "align_functions", ";", "else", "align", "=", "max_align", ";", "ofs", "=", "prev_in_use", "=", "0", ";", "i", "=", "get_insns", "(", ")", ";", "if", "(", "GET_CODE", "(", "i", ")", "==", "NOTE", ")", "i", "=", "next_nonnote_insn", "(", "i", ")", ";", "ldgp", "=", "alpha_function_needs_gp", "?", "8", ":", "0", ";", "while", "(", "i", ")", "{", "next", "=", "(", "*", "next_group", ")", "(", "i", ",", "&", "in_use", ",", "&", "len", ")", ";", "if", "(", "GET_CODE", "(", "i", ")", "==", "CODE_LABEL", ")", "{", "unsigned", "int", "new_align", "=", "1", "<<", "label_to_alignment", "(", "i", ")", ";", "if", "(", "new_align", ">=", "align", ")", "{", "align", "=", "new_align", "<", "max_align", "?", "new_align", ":", "max_align", ";", "ofs", "=", "0", ";", "}", "else", "if", "(", "ofs", "&", "(", "new_align", "-", "1", ")", ")", "ofs", "=", "(", "ofs", "|", "(", "new_align", "-", "1", ")", ")", "+", "1", ";", "gcc_assert", "(", "!", "len", ")", ";", "}", "else", "if", "(", "in_use", "==", "0", ")", "{", "if", "(", "len", "<", "0", ")", "{", "ofs", "=", "0", ";", "align", "=", "4", ";", "len", "=", "0", ";", "}", "}", "else", "if", "(", "(", "int", ")", "align", "<", "len", ")", "{", "unsigned", "int", "new_log_align", "=", "len", ">", "8", "?", "4", ":", "3", ";", "rtx", "prev", ",", "where", ";", "where", "=", "prev", "=", "prev_nonnote_insn", "(", "i", ")", ";", "if", "(", "!", "where", "||", "GET_CODE", "(", "where", ")", "!=", "CODE_LABEL", ")", "where", "=", "i", ";", "if", "(", "!", "(", "TARGET_EXPLICIT_RELOCS", "&&", "prev", "&&", "GET_CODE", "(", "prev", ")", "==", "CALL_INSN", ")", ")", "{", "emit_insn_before", "(", "gen_realign", "(", "GEN_INT", "(", "new_log_align", ")", ")", ",", "where", ")", ";", "align", "=", "1", "<<", "new_log_align", ";", "ofs", "=", "0", ";", "}", "}", "else", "if", "(", "ldgp", ">", "0", ")", "ldgp", "-=", "len", ";", "else", "if", "(", "ofs", "+", "len", ">", "(", "int", ")", "align", ")", "{", "int", "nop_count", "=", "(", "align", "-", "ofs", ")", "/", "4", ";", "rtx", "where", ";", "where", "=", "prev_nonnote_insn", "(", "i", ")", ";", "if", "(", "where", ")", "{", "if", "(", "GET_CODE", "(", "where", ")", "==", "CODE_LABEL", ")", "{", "rtx", "where2", "=", "prev_nonnote_insn", "(", "where", ")", ";", "if", "(", "where2", "&&", "GET_CODE", "(", "where2", ")", "==", "JUMP_INSN", ")", "where", "=", "where2", ";", "}", "else", "if", "(", "GET_CODE", "(", "where", ")", "==", "INSN", ")", "where", "=", "i", ";", "}", "else", "where", "=", "i", ";", "do", "emit_insn_before", "(", "(", "*", "next_nop", ")", "(", "&", "prev_in_use", ")", ",", "where", ")", ";", "while", "(", "--", "nop_count", ")", ";", "ofs", "=", "0", ";", "}", "ofs", "=", "(", "ofs", "+", "len", ")", "&", "(", "align", "-", "1", ")", ";", "prev_in_use", "=", "in_use", ";", "i", "=", "next", ";", "}", "}", "</s>" ]

[ "The", "instruction", "group", "alignment", "main", "loop", "." ]

[ "alpha", "4", "4", "0", "8", "0", "1", "0", "1", "1", "1", "0", "0", "0", "4", "0", "8", "4", "3", "1", "0", "0", "4", "0", "1" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Sparc Double-FP Move Fixer\"", ";", "}", "</s>" ]

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

[ "Sparc", "\"Sparc Double-FP Move Fixer\"" ]

[]

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

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

[ "mips", "0" ]

[]

[ "<s>", "int", "aarch64_simd_attr_length_move", "(", "rtx_insn", "*", "insn", ")", "{", "machine_mode", "mode", ";", "extract_insn_cached", "(", "insn", ")", ";", "if", "(", "REG_P", "(", "recog_data", ".", "operand", "[", "0", "]", ")", "&&", "REG_P", "(", "recog_data", ".", "operand", "[", "1", "]", ")", ")", "{", "mode", "=", "GET_MODE", "(", "recog_data", ".", "operand", "[", "0", "]", ")", ";", "switch", "(", "mode", ")", "{", "case", "OImode", ":", "return", "8", ";", "case", "CImode", ":", "return", "12", ";", "case", "XImode", ":", "return", "16", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "return", "4", ";", "}", "</s>" ]

[ "Compute", "and", "return", "the", "length", "of", "aarch64_simd_mov", "<", "mode", ">", ",", "where", "<", "mode", ">", "is", "one", "of", "VSTRUCT", "modes", ":", "OI", ",", "CI", "or", "XI", "." ]

[ "aarch64", "0", "1", "0", "8", "12", "16", "4" ]

[]

[ "<s>", "char", "*", "output_e500_flip_gt_bit", "(", "rtx", "dst", ",", "rtx", "src", ")", "{", "static", "char", "string", "[", "64", "]", ";", "int", "a", ",", "b", ";", "gcc_assert", "(", "GET_CODE", "(", "dst", ")", "==", "REG", "&&", "CR_REGNO_P", "(", "REGNO", "(", "dst", ")", ")", "&&", "GET_CODE", "(", "src", ")", "==", "REG", "&&", "CR_REGNO_P", "(", "REGNO", "(", "src", ")", ")", ")", ";", "a", "=", "4", "*", "(", "REGNO", "(", "dst", ")", "-", "CR0_REGNO", ")", "+", "1", ";", "b", "=", "4", "*", "(", "REGNO", "(", "src", ")", "-", "CR0_REGNO", ")", "+", "1", ";", "sprintf", "(", "string", ",", "\"crnot %d,%d\"", ",", "a", ",", "b", ")", ";", "return", "string", ";", "}", "</s>" ]

[ "Return", "the", "string", "to", "flip", "the", "GT", "bit", "on", "a", "CR", "." ]

[ "powerpcspe", "64", "4", "1", "4", "1", "\"crnot %d,%d\"" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "AAPOperand", ">", "CreateReg", "(", "unsigned", "RegNo", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "auto", "Op", "=", "make_unique", "<", "AAPOperand", ">", "(", "Register", ")", ";", "Op", "->", "Reg", ".", "RegNum", "=", "RegNo", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

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

[]

[ "<s>", "virtual", "MVT", "getShiftAmountTy", "(", "EVT", "LHSTy", ")", "const", "{", "return", "MVT", "::", "i8", ";", "}", "</s>" ]

[ "Returns", "the", "type", "for", "the", "shift", "amount", "of", "a", "shift", "opcode", "." ]

[ "X86", "MVT::i8" ]

[]

[ "<s>", "bool", "SIAnnotateControlFlow", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "DT", "=", "&", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "DA", "=", "&", "getAnalysis", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "for", "(", "df_iterator", "<", "BasicBlock", "*", ">", "I", "=", "df_begin", "(", "&", "F", ".", "getEntryBlock", "(", ")", ")", ",", "E", "=", "df_end", "(", "&", "F", ".", "getEntryBlock", "(", ")", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "BasicBlock", "*", "BB", "=", "*", "I", ";", "BranchInst", "*", "Term", "=", "dyn_cast", "<", "BranchInst", ">", "(", "BB", "->", "getTerminator", "(", ")", ")", ";", "if", "(", "!", "Term", "||", "Term", "->", "isUnconditional", "(", ")", ")", "{", "if", "(", "isTopOfStack", "(", "BB", ")", ")", "closeControlFlow", "(", "BB", ")", ";", "continue", ";", "}", "if", "(", "I", ".", "nodeVisited", "(", "Term", "->", "getSuccessor", "(", "1", ")", ")", ")", "{", "if", "(", "isTopOfStack", "(", "BB", ")", ")", "closeControlFlow", "(", "BB", ")", ";", "handleLoop", "(", "Term", ")", ";", "continue", ";", "}", "if", "(", "isTopOfStack", "(", "BB", ")", ")", "{", "PHINode", "*", "Phi", "=", "dyn_cast", "<", "PHINode", ">", "(", "Term", "->", "getCondition", "(", ")", ")", ";", "if", "(", "Phi", "&&", "Phi", "->", "getParent", "(", ")", "==", "BB", "&&", "isElse", "(", "Phi", ")", ")", "{", "insertElse", "(", "Term", ")", ";", "eraseIfUnused", "(", "Phi", ")", ";", "continue", ";", "}", "closeControlFlow", "(", "BB", ")", ";", "}", "openIf", "(", "Term", ")", ";", "}", "if", "(", "!", "Stack", ".", "empty", "(", ")", ")", "{", "report_fatal_error", "(", "\"failed to annotate CFG\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "1", "\"failed to annotate CFG\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Fix SGPR copies\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SI Fix SGPR copies\"" ]

[]

[ "<s>", "bool", "aarch64_offset_7bit_signed_scaled_p", "(", "machine_mode", "mode", ",", "poly_int64", "offset", ")", "{", "HOST_WIDE_INT", "multiple", ";", "return", "(", "constant_multiple_p", "(", "offset", ",", "GET_MODE_SIZE", "(", "mode", ")", ",", "&", "multiple", ")", "&&", "IN_RANGE", "(", "multiple", ",", "-", "64", ",", "63", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OFFSET", "is", "a", "signed", "7-bit", "value", "multiplied", "by", "the", "size", "of", "MODE", "." ]

[ "aarch64", "64", "63" ]

[]

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

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "ARM" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AddrSpace", ",", "Align", "Alignment", ",", "MachineMemOperand", "::", "Flags", "Flags", ",", "bool", "*", "IsFast", ")", "const", "{", "bool", "Allow", "=", "allowsMisalignedMemoryAccessesImpl", "(", "VT", ".", "getSizeInBits", "(", ")", ",", "AddrSpace", ",", "Alignment", ",", "Flags", ",", "IsFast", ")", ";", "if", "(", "Allow", "&&", "IsFast", "&&", "Subtarget", "->", "hasUnalignedDSAccessEnabled", "(", ")", "&&", "(", "AddrSpace", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", "||", "AddrSpace", "==", "AMDGPUAS", "::", "REGION_ADDRESS", ")", ")", "{", "*", "IsFast", "=", "true", ";", "}", "return", "Allow", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "arm_legitimate_constant_p_1", "(", "machine_mode", ",", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", "&&", "!", "neon_make_constant", "(", "x", ",", "false", ")", ")", "return", "false", ";", "return", "flag_pic", "||", "!", "label_mentioned_p", "(", "x", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_CONSTANT_P", ".", "On", "the", "ARM", ",", "allow", "any", "integer", "(", "invalid", "ones", "are", "removed", "later", "by", "insn", "patterns", ")", ",", "nice", "doubles", "and", "symbol_refs", "which", "refer", "to", "the", "function", "'s", "constant", "pool", "XXX", ".", "When", "generating", "pic", "allow", "anything", "." ]

[ "arm" ]

[]

[ "<s>", "static", "void", "rl78_start_function", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "hwi_local", "ATTRIBUTE_UNUSED", ")", "{", "int", "i", ";", "if", "(", "cfun", "->", "machine", "->", "framesize", "==", "0", ")", "return", ";", "fprintf", "(", "file", ",", "\"\\t; start of function\\n\"", ")", ";", "if", "(", "cfun", "->", "machine", "->", "framesize_regs", ")", "{", "fprintf", "(", "file", ",", "\"\\t; push %d:\"", ",", "cfun", "->", "machine", "->", "framesize_regs", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "16", ";", "i", "++", ")", "if", "(", "cfun", "->", "machine", "->", "need_to_push", "[", "i", "]", ")", "fprintf", "(", "file", ",", "\" %s\"", ",", "word_regnames", "[", "i", "*", "2", "]", ")", ";", "fprintf", "(", "file", ",", "\"\\n\"", ")", ";", "}", "if", "(", "frame_pointer_needed", ")", "fprintf", "(", "file", ",", "\"\\t; $fp points here (r22)\\n\"", ")", ";", "if", "(", "cfun", "->", "machine", "->", "framesize_locals", ")", "fprintf", "(", "file", ",", "\"\\t; locals: %d byte%s\\n\"", ",", "cfun", "->", "machine", "->", "framesize_locals", ",", "cfun", "->", "machine", "->", "framesize_locals", "==", "1", "?", "\"\"", ":", "\"s\"", ")", ";", "if", "(", "cfun", "->", "machine", "->", "framesize_outgoing", ")", "fprintf", "(", "file", ",", "\"\\t; outgoing: %d byte%s\\n\"", ",", "cfun", "->", "machine", "->", "framesize_outgoing", ",", "cfun", "->", "machine", "->", "framesize_outgoing", "==", "1", "?", "\"\"", ":", "\"s\"", ")", ";", "if", "(", "cfun", "->", "machine", "->", "uses_es", ")", "fprintf", "(", "file", ",", "\"\\t; uses ES register\\n\"", ")", ";", "}", "</s>" ]

[ "We", "do", "n't", "use", "this", "to", "actually", "emit", "the", "function", "prologue", ".", "We", "use", "this", "to", "insert", "a", "comment", "in", "the", "asm", "file", "describing", "the", "function", "." ]

[ "rl78", "0", "\"\\t; start of function\\n\"", "\"\\t; push %d:\"", "0", "16", "\" %s\"", "2", "\"\\n\"", "\"\\t; $fp points here (r22)\\n\"", "\"\\t; locals: %d byte%s\\n\"", "1", "\"\"", "\"s\"", "\"\\t; outgoing: %d byte%s\\n\"", "1", "\"\"", "\"s\"", "\"\\t; uses ES register\\n\"" ]

[]

[ "<s>", "unsigned", "int", "reg_or_subreg_regno", "(", "rtx", "op", ")", "{", "unsigned", "int", "regno", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "REG", ")", "regno", "=", "REGNO", "(", "op", ")", ";", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "SUBREG", "&&", "GET_CODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "REG", ")", "{", "if", "(", "REGNO", "(", "SUBREG_REG", "(", "op", ")", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "regno", "=", "subreg_regno", "(", "op", ")", ";", "else", "regno", "=", "REGNO", "(", "SUBREG_REG", "(", "op", ")", ")", ";", "}", "else", "regno", "=", "INVALID_REGNUM", ";", "return", "regno", ";", "}", "</s>" ]

[ "Return", "the", "register", "number", "if", "OP", "is", "a", "REG", "or", "a", "SUBREG", "of", "a", "REG", ",", "and", "INVALID_REGNUM", "in", "all", "the", "other", "cases", "." ]

[ "visium" ]

[]

[ "<s>", "const", "char", "*", "MipsTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "MipsISD", "::", "JmpLink", ":", "return", "\"MipsISD::JmpLink\"", ";", "case", "MipsISD", "::", "Hi", ":", "return", "\"MipsISD::Hi\"", ";", "case", "MipsISD", "::", "Lo", ":", "return", "\"MipsISD::Lo\"", ";", "case", "MipsISD", "::", "GPRel", ":", "return", "\"MipsISD::GPRel\"", ";", "case", "MipsISD", "::", "Ret", ":", "return", "\"MipsISD::Ret\"", ";", "case", "MipsISD", "::", "SelectCC", ":", "return", "\"MipsISD::SelectCC\"", ";", "case", "MipsISD", "::", "FPSelectCC", ":", "return", "\"MipsISD::FPSelectCC\"", ";", "case", "MipsISD", "::", "FPBrcond", ":", "return", "\"MipsISD::FPBrcond\"", ";", "case", "MipsISD", "::", "FPCmp", ":", "return", "\"MipsISD::FPCmp\"", ";", "case", "MipsISD", "::", "FPRound", ":", "return", "\"MipsISD::FPRound\"", ";", "case", "MipsISD", "::", "MAdd", ":", "return", "\"MipsISD::MAdd\"", ";", "case", "MipsISD", "::", "MAddu", ":", "return", "\"MipsISD::MAddu\"", ";", "case", "MipsISD", "::", "MSub", ":", "return", "\"MipsISD::MSub\"", ";", "case", "MipsISD", "::", "MSubu", ":", "return", "\"MipsISD::MSubu\"", ";", "case", "MipsISD", "::", "DivRem", ":", "return", "\"MipsISD::DivRem\"", ";", "case", "MipsISD", "::", "DivRemU", ":", "return", "\"MipsISD::DivRemU\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "MipsISD::JmpLink", "\"MipsISD::JmpLink\"", "MipsISD::Hi", "\"MipsISD::Hi\"", "MipsISD::Lo", "\"MipsISD::Lo\"", "MipsISD::GPRel", "\"MipsISD::GPRel\"", "MipsISD::Ret", "\"MipsISD::Ret\"", "MipsISD::SelectCC", "\"MipsISD::SelectCC\"", "MipsISD::FPSelectCC", "\"MipsISD::FPSelectCC\"", "MipsISD::FPBrcond", "\"MipsISD::FPBrcond\"", "MipsISD::FPCmp", "\"MipsISD::FPCmp\"", "MipsISD::FPRound", "\"MipsISD::FPRound\"", "MipsISD::MAdd", "\"MipsISD::MAdd\"", "MipsISD::MAddu", "\"MipsISD::MAddu\"", "MipsISD::MSub", "\"MipsISD::MSub\"", "MipsISD::MSubu", "\"MipsISD::MSubu\"", "MipsISD::DivRem", "\"MipsISD::DivRem\"", "MipsISD::DivRemU", "\"MipsISD::DivRemU\"" ]

[]

[ "<s>", "static", "bool", "find_mem_ref", "(", "rtx", "pat", ",", "rtx", "*", "mem_ref", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ",", "j", ";", "if", "(", "tie_operand", "(", "pat", ",", "VOIDmode", ")", ")", "return", "false", ";", "if", "(", "MEM_P", "(", "pat", ")", ")", "{", "*", "mem_ref", "=", "pat", ";", "return", "true", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "pat", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "pat", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'e'", ")", "{", "if", "(", "find_mem_ref", "(", "XEXP", "(", "pat", ",", "i", ")", ",", "mem_ref", ")", ")", "return", "true", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "for", "(", "j", "=", "XVECLEN", "(", "pat", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "{", "if", "(", "find_mem_ref", "(", "XVECEXP", "(", "pat", ",", "i", ",", "j", ")", ",", "mem_ref", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Determine", "if", "PAT", "refers", "to", "memory", ".", "If", "so", ",", "set", "MEM_REF", "to", "the", "MEM", "rtx", "and", "return", "true", "." ]

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

[]

[ "<s>", "const", "JVMRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "getInstrInfo", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "JVM", "JVM" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "AMDGPUArgumentUsageInfo", ">", "(", ")", ";", "SelectionDAGISel", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "finalizeLowering", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "Info", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "if", "(", "Info", "->", "isEntryFunction", "(", ")", ")", "{", "reservePrivateMemoryRegs", "(", "getTargetMachine", "(", ")", ",", "MF", ",", "*", "TRI", ",", "*", "Info", ")", ";", "}", "assert", "(", "!", "TRI", "->", "isSubRegister", "(", "Info", "->", "getScratchRSrcReg", "(", ")", ",", "Info", "->", "getStackPtrOffsetReg", "(", ")", ")", ")", ";", "if", "(", "Info", "->", "getStackPtrOffsetReg", "(", ")", "!=", "AMDGPU", "::", "SP_REG", ")", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "SP_REG", ",", "Info", "->", "getStackPtrOffsetReg", "(", ")", ")", ";", "if", "(", "Info", "->", "getScratchRSrcReg", "(", ")", "!=", "AMDGPU", "::", "PRIVATE_RSRC_REG", ")", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "PRIVATE_RSRC_REG", ",", "Info", "->", "getScratchRSrcReg", "(", ")", ")", ";", "if", "(", "Info", "->", "getFrameOffsetReg", "(", ")", "!=", "AMDGPU", "::", "FP_REG", ")", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "FP_REG", ",", "Info", "->", "getFrameOffsetReg", "(", ")", ")", ";", "Info", "->", "limitOccupancy", "(", "MF", ")", ";", "if", "(", "ST", ".", "isWave32", "(", ")", "&&", "!", "MF", ".", "empty", "(", ")", ")", "{", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "TII", "->", "fixImplicitOperands", "(", "MI", ")", ";", "}", "}", "}", "TargetLoweringBase", "::", "finalizeLowering", "(", "MF", ")", ";", "if", "(", "VGPRReserveforSGPRSpill", "&&", "!", "Info", "->", "VGPRReservedForSGPRSpill", "&&", "!", "Info", "->", "isEntryFunction", "(", ")", "&&", "MF", ".", "getFrameInfo", "(", ")", ".", "hasStackObjects", "(", ")", ")", "Info", "->", "reserveVGPRforSGPRSpills", "(", "MF", ")", ";", "}", "</s>" ]

[ "Execute", "target", "specific", "actions", "to", "finalize", "target", "lowering", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "AMDGPU::SP_REG", "AMDGPU::SP_REG", "AMDGPU::PRIVATE_RSRC_REG", "AMDGPU::PRIVATE_RSRC_REG", "AMDGPU::FP_REG", "AMDGPU::FP_REG", "SI" ]

[]

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

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

[ "Cpu0" ]

[]

[ "<s>", "const", "char", "*", "MipsTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "MipsISD", "::", "JmpLink", ":", "return", "\"MipsISD::JmpLink\"", ";", "case", "MipsISD", "::", "Hi", ":", "return", "\"MipsISD::Hi\"", ";", "case", "MipsISD", "::", "Lo", ":", "return", "\"MipsISD::Lo\"", ";", "case", "MipsISD", "::", "GPRel", ":", "return", "\"MipsISD::GPRel\"", ";", "case", "MipsISD", "::", "Ret", ":", "return", "\"MipsISD::Ret\"", ";", "case", "MipsISD", "::", "SelectCC", ":", "return", "\"MipsISD::SelectCC\"", ";", "case", "MipsISD", "::", "FPSelectCC", ":", "return", "\"MipsISD::FPSelectCC\"", ";", "case", "MipsISD", "::", "FPBrcond", ":", "return", "\"MipsISD::FPBrcond\"", ";", "case", "MipsISD", "::", "FPCmp", ":", "return", "\"MipsISD::FPCmp\"", ";", "case", "MipsISD", "::", "FPRound", ":", "return", "\"MipsISD::FPRound\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "MipsISD::JmpLink", "\"MipsISD::JmpLink\"", "MipsISD::Hi", "\"MipsISD::Hi\"", "MipsISD::Lo", "\"MipsISD::Lo\"", "MipsISD::GPRel", "\"MipsISD::GPRel\"", "MipsISD::Ret", "\"MipsISD::Ret\"", "MipsISD::SelectCC", "\"MipsISD::SelectCC\"", "MipsISD::FPSelectCC", "\"MipsISD::FPSelectCC\"", "MipsISD::FPBrcond", "\"MipsISD::FPBrcond\"", "MipsISD::FPCmp", "\"MipsISD::FPCmp\"", "MipsISD::FPRound", "\"MipsISD::FPRound\"" ]

[]

[ "<s>", "void", "SystemZInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "O", ",", "unsigned", "RegNo", ")", "const", "{", "O", "<<", "'%'", "<<", "getRegisterName", "(", "RegNo", ")", ";", "}", "</s>" ]

[ "Print", "the", "assembler", "register", "name", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "GBZ80PostRA", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Modified", "=", "false", ";", "this", "->", "MF", "=", "&", "MF", ";", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "Modified", "|=", "expandPostRAPseudos", "(", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "GB", "GB" ]

[]

[ "<s>", "static", "int", "ia64_dfa_new_cycle", "(", "FILE", "*", "dump", ",", "int", "verbose", ",", "rtx_insn", "*", "insn", ",", "int", "last_clock", ",", "int", "clock", ",", "int", "*", "sort_p", ")", "{", "gcc_assert", "(", "insn", "&&", "INSN_P", "(", "insn", ")", ")", ";", "if", "(", "DEBUG_INSN_P", "(", "insn", ")", ")", "return", "0", ";", "gcc_assert", "(", "!", "(", "reload_completed", "&&", "safe_group_barrier_needed", "(", "insn", ")", ")", "||", "last_scheduled_insn", ")", ";", "if", "(", "(", "reload_completed", "&&", "(", "safe_group_barrier_needed", "(", "insn", ")", "||", "(", "mflag_sched_stop_bits_after_every_cycle", "&&", "last_clock", "!=", "clock", "&&", "last_scheduled_insn", "&&", "scheduled_good_insn", "(", "last_scheduled_insn", ")", ")", ")", ")", "||", "(", "last_scheduled_insn", "&&", "(", "CALL_P", "(", "last_scheduled_insn", ")", "||", "unknown_for_bundling_p", "(", "last_scheduled_insn", ")", ")", ")", ")", "{", "init_insn_group_barriers", "(", ")", ";", "if", "(", "verbose", "&&", "dump", ")", "fprintf", "(", "dump", ",", "\"// Stop should be before %d%s\\n\"", ",", "INSN_UID", "(", "insn", ")", ",", "last_clock", "==", "clock", "?", "\" + cycle advance\"", ":", "\"\"", ")", ";", "stop_before_p", "=", "1", ";", "current_cycle", "=", "clock", ";", "mem_ops_in_group", "[", "current_cycle", "%", "4", "]", "=", "0", ";", "if", "(", "last_clock", "==", "clock", ")", "{", "state_transition", "(", "curr_state", ",", "dfa_stop_insn", ")", ";", "if", "(", "TARGET_EARLY_STOP_BITS", ")", "*", "sort_p", "=", "(", "last_scheduled_insn", "==", "NULL_RTX", "||", "!", "CALL_P", "(", "last_scheduled_insn", ")", ")", ";", "else", "*", "sort_p", "=", "0", ";", "return", "1", ";", "}", "if", "(", "last_scheduled_insn", ")", "{", "if", "(", "unknown_for_bundling_p", "(", "last_scheduled_insn", ")", ")", "state_reset", "(", "curr_state", ")", ";", "else", "{", "memcpy", "(", "curr_state", ",", "prev_cycle_state", ",", "dfa_state_size", ")", ";", "state_transition", "(", "curr_state", ",", "dfa_stop_insn", ")", ";", "state_transition", "(", "curr_state", ",", "dfa_pre_cycle_insn", ")", ";", "state_transition", "(", "curr_state", ",", "NULL", ")", ";", "}", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "We", "are", "about", "to", "being", "issuing", "INSN", ".", "Return", "nonzero", "if", "we", "can", "not", "issue", "it", "on", "given", "cycle", "CLOCK", "and", "return", "zero", "if", "we", "should", "not", "sort", "the", "ready", "queue", "on", "the", "next", "clock", "start", "." ]

[ "ia64", "0", "\"// Stop should be before %d%s\\n\"", "\" + cycle advance\"", "\"\"", "1", "4", "0", "0", "1", "0" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "SystemZTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'d'", ":", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "GR64BitRegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "i128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "GR128BitRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "GR32BitRegClass", ")", ";", "case", "'a'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "ADDR64BitRegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "i128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "ADDR128BitRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "ADDR32BitRegClass", ")", ";", "case", "'h'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "GRH32BitRegClass", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "FP64BitRegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "f128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "FP128BitRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "FP32BitRegClass", ")", ";", "}", "}", "if", "(", "Constraint", "[", "0", "]", "==", "'{'", ")", "{", "if", "(", "Constraint", "[", "1", "]", "==", "'r'", ")", "{", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "return", "parseRegisterNumber", "(", "Constraint", ",", "&", "SystemZ", "::", "GR32BitRegClass", ",", "SystemZMC", "::", "GR32Regs", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i128", ")", "return", "parseRegisterNumber", "(", "Constraint", ",", "&", "SystemZ", "::", "GR128BitRegClass", ",", "SystemZMC", "::", "GR128Regs", ")", ";", "return", "parseRegisterNumber", "(", "Constraint", ",", "&", "SystemZ", "::", "GR64BitRegClass", ",", "SystemZMC", "::", "GR64Regs", ")", ";", "}", "if", "(", "Constraint", "[", "1", "]", "==", "'f'", ")", "{", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "parseRegisterNumber", "(", "Constraint", ",", "&", "SystemZ", "::", "FP32BitRegClass", ",", "SystemZMC", "::", "FP32Regs", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f128", ")", "return", "parseRegisterNumber", "(", "Constraint", ",", "&", "SystemZ", "::", "FP128BitRegClass", ",", "SystemZMC", "::", "FP128Regs", ")", ";", "return", "parseRegisterNumber", "(", "Constraint", ",", "&", "SystemZ", "::", "FP64BitRegClass", ",", "SystemZMC", "::", "FP64Regs", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "1", "0", "MVT::i64", "0U", "SystemZ::GR64BitRegClass", "MVT::i128", "0U", "SystemZ::GR128BitRegClass", "0U", "SystemZ::GR32BitRegClass", "MVT::i64", "0U", "SystemZ::ADDR64BitRegClass", "MVT::i128", "0U", "SystemZ::ADDR128BitRegClass", "0U", "SystemZ::ADDR32BitRegClass", "0U", "SystemZ::GRH32BitRegClass", "MVT::f64", "0U", "SystemZ::FP64BitRegClass", "MVT::f128", "0U", "SystemZ::FP128BitRegClass", "0U", "SystemZ::FP32BitRegClass", "0", "1", "MVT::i32", "SystemZ::GR32BitRegClass", "SystemZMC::GR32Regs", "MVT::i128", "SystemZ::GR128BitRegClass", "SystemZMC::GR128Regs", "SystemZ::GR64BitRegClass", "SystemZMC::GR64Regs", "1", "MVT::f32", "SystemZ::FP32BitRegClass", "SystemZMC::FP32Regs", "MVT::f128", "SystemZ::FP128BitRegClass", "SystemZMC::FP128Regs", "SystemZ::FP64BitRegClass", "SystemZMC::FP64Regs" ]

[]

[ "<s>", "bool", "X86IndirectBranchTrackingPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86Subtarget", "&", "SubTarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "SubTarget", ".", "hasIBT", "(", ")", ")", "return", "false", ";", "Metadata", "*", "isCFProtectionSupported", "=", "MF", ".", "getMMI", "(", ")", ".", "getModule", "(", ")", "->", "getModuleFlag", "(", "\"cf-protection-branch\"", ")", ";", "if", "(", "!", "isCFProtectionSupported", "&&", "!", "IndirectBranchTracking", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "TII", "=", "SubTarget", ".", "getInstrInfo", "(", ")", ";", "EndbrOpcode", "=", "SubTarget", ".", "is64Bit", "(", ")", "?", "X86", "::", "ENDBR64", ":", "X86", "::", "ENDBR32", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasAddressTaken", "(", ")", "||", "!", "MF", ".", "getFunction", "(", ")", ".", "hasLocalLinkage", "(", ")", ")", "{", "auto", "MBB", "=", "MF", ".", "begin", "(", ")", ";", "addENDBR", "(", "*", "MBB", ")", ";", "Changed", "=", "true", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "if", "(", "MBB", ".", "hasAddressTaken", "(", ")", ")", "{", "addENDBR", "(", "MBB", ")", ";", "Changed", "=", "true", ";", "}", "}", "if", "(", "MachineJumpTableInfo", "*", "JTI", "=", "MF", ".", "getJumpTableInfo", "(", ")", ")", "{", "for", "(", "const", "auto", "&", "JT", ":", "JTI", "->", "getJumpTables", "(", ")", ")", "{", "for", "(", "auto", "*", "MBB", ":", "JT", ".", "MBBs", ")", "{", "assert", "(", "verifyIndirectJump", "(", "MBB", ")", "&&", "\"The MBB is not the destination of an indirect jump\"", ")", ";", "addENDBR", "(", "*", "MBB", ")", ";", "Changed", "=", "true", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"cf-protection-branch\"", "X86::ENDBR64", "X86::ENDBR32", "\"The MBB is not the destination of an indirect jump\"" ]

[]

[ "<s>", "static", "rtx", "s390_two_part_insv", "(", "struct", "alignment_context", "*", "ac", ",", "rtx", "*", "seq1", ",", "rtx", "*", "seq2", ",", "machine_mode", "mode", ",", "rtx", "val", ",", "rtx", "ins", ")", "{", "rtx", "tmp", ";", "if", "(", "ac", "->", "aligned", ")", "{", "start_sequence", "(", ")", ";", "tmp", "=", "copy_to_mode_reg", "(", "SImode", ",", "val", ")", ";", "if", "(", "s390_expand_insv", "(", "tmp", ",", "GEN_INT", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ")", ",", "const0_rtx", ",", "ins", ")", ")", "{", "*", "seq1", "=", "NULL", ";", "*", "seq2", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "tmp", ";", "}", "end_sequence", "(", ")", ";", "}", "start_sequence", "(", ")", ";", "tmp", "=", "s390_expand_mask_and_shift", "(", "ins", ",", "mode", ",", "ac", "->", "shift", ")", ";", "*", "seq1", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "start_sequence", "(", ")", ";", "tmp", "=", "expand_simple_binop", "(", "SImode", ",", "IOR", ",", "tmp", ",", "val", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "*", "seq2", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "tmp", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "s390_expand_cs_hqi", ".", "Insert", "INS", "into", "VAL", ".", "If", "possible", ",", "use", "a", "single", "insv", "insn", "into", "SEQ2", ".", "Otherwise", ",", "put", "prep", "insns", "in", "SEQ1", "and", "perform", "the", "merge", "in", "SEQ2", "." ]

[ "s390", "1" ]

[]

[ "<s>", "void", "Tile64RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "unsigned", "DestReg", "=", "0", ";", "MachineOperand", "*", "FrameIndexOp", "=", "0", ";", "if", "(", "Opc", "==", "T64", "::", "MOVFI", ")", "{", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "FrameIndexOp", "=", "&", "MI", ".", "getOperand", "(", "1", ")", ";", "}", "else", "if", "(", "Opc", "==", "T64", "::", "SW", "||", "Opc", "==", "T64", "::", "LW", ")", "{", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "DestReg", "=", "T64", "::", "R51", ";", "FrameIndexOp", "=", "&", "MI", ".", "getOperand", "(", "i", ")", ";", "}", "int", "Offset", "=", "MF", "->", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndexOp", "->", "getIndex", "(", ")", ")", ";", "addOffset", "(", "MBB", ",", "II", ",", "DL", ",", "DestReg", ",", "T64", "::", "FramePointer", ",", "Offset", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "llvm_unreachable", "(", "\"FrameIndex in unexpected instruction!\"", ")", ";", "case", "T64", "::", "MOVFI", ":", "MI", ".", "eraseFromParent", "(", ")", ";", "break", ";", "case", "T64", "::", "SW", ":", "case", "T64", "::", "LW", ":", "FrameIndexOp", "->", "ChangeToRegister", "(", "DestReg", ",", "false", ")", ";", "break", ";", "}", "}", "</s>" ]

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

[ "Tile64", "0", "\"Unexpected\"", "0", "0", "T64::MOVFI", "0", "1", "T64::SW", "T64::LW", "0", "\"Instr doesn't have FrameIndex operand!\"", "T64::R51", "T64::FramePointer", "\"FrameIndex in unexpected instruction!\"", "T64::MOVFI", "T64::SW", "T64::LW" ]

[]

[ "<s>", "unsigned", "PPCRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "Subtarget", ".", "getFrameLowering", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "PPC", "::", "R31", ":", "PPC", "::", "R1", ";", "else", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "PPC", "::", "X31", ":", "PPC", "::", "X1", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC::R31", "PPC::R1", "PPC::X31", "PPC::X1" ]

[]

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

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

[ "RISCV" ]

[]

[ "<s>", "static", "rtx", "shifter_op_p", "(", "rtx", "op", ",", "rtx", "*", "shift_reg", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "if", "(", "code", "==", "MULT", "&&", "CONST_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", "&&", "exact_log2", "(", "INTVAL", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", ">", "0", ")", "return", "XEXP", "(", "op", ",", "0", ")", ";", "else", "if", "(", "code", "==", "ROTATE", "&&", "CONST_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "return", "XEXP", "(", "op", ",", "0", ")", ";", "else", "if", "(", "code", "==", "ROTATERT", "||", "code", "==", "ASHIFT", "||", "code", "==", "LSHIFTRT", "||", "code", "==", "ASHIFTRT", ")", "{", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "*", "shift_reg", "=", "XEXP", "(", "op", ",", "1", ")", ";", "return", "XEXP", "(", "op", ",", "0", ")", ";", "}", "return", "NULL", ";", "}", "</s>" ]

[ "Helper", "function", "for", "arm_rtx_costs", ".", "If", "the", "operand", "is", "a", "valid", "shift", "operand", ",", "then", "return", "the", "operand", "that", "is", "being", "shifted", ".", "If", "the", "shift", "is", "not", "by", "a", "constant", ",", "then", "set", "SHIFT_REG", "to", "point", "to", "the", "operand", ".", "Return", "NULL", "if", "OP", "is", "not", "a", "shifter", "operand", "." ]

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

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "{", "return", "Mips", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "Mips", "Mips::NumTargetFixupKinds" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "MOSRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "MOSFrameLowering", "&", "TFI", "=", "*", "getFrameLowering", "(", "*", "MF", ")", ";", "return", "TFI", ".", "isISR", "(", "*", "MF", ")", "?", "MOS_Interrupt_CSR_SaveList", ":", "MOS_CSR_SaveList", ";", "}", "</s>" ]

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

[ "MOS", "MOS", "MOS", "MOS", "MOS" ]

[]

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

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

[ "IA64", "IA64" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "createVR", "(", "MachineFunction", "*", "MF", ",", "MVT", "VT", ")", "const", "{", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "TRC", ";", "if", "(", "VT", "==", "MVT", "::", "i1", ")", "{", "TRC", "=", "&", "Hexagon", "::", "PredRegsRegClass", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "f32", ")", "{", "TRC", "=", "&", "Hexagon", "::", "IntRegsRegClass", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "i64", "||", "VT", "==", "MVT", "::", "f64", ")", "{", "TRC", "=", "&", "Hexagon", "::", "DoubleRegsRegClass", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot handle this register class\"", ")", ";", "}", "unsigned", "NewReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "TRC", ")", ";", "return", "NewReg", ";", "}", "</s>" ]

[ "HexagonInstrInfo", "specifics", "." ]

[ "Hexagon", "Hexagon", "MVT::i1", "Hexagon::PredRegsRegClass", "MVT::i32", "MVT::f32", "Hexagon::IntRegsRegClass", "MVT::i64", "MVT::f64", "Hexagon::DoubleRegsRegClass", "\"Cannot handle this register class\"" ]

[]

[ "<s>", "void", "PPCPostRASchedStrategy", "::", "tryCandidate", "(", "SchedCandidate", "&", "Cand", ",", "SchedCandidate", "&", "TryCand", ")", "{", "if", "(", "!", "Cand", ".", "isValid", "(", ")", ")", "{", "TryCand", ".", "Reason", "=", "NodeOrder", ";", "return", ";", "}", "if", "(", "tryLess", "(", "Top", ".", "getLatencyStallCycles", "(", "TryCand", ".", "SU", ")", ",", "Top", ".", "getLatencyStallCycles", "(", "Cand", ".", "SU", ")", ",", "TryCand", ",", "Cand", ",", "Stall", ")", ")", "return", ";", "if", "(", "tryGreater", "(", "TryCand", ".", "SU", "==", "DAG", "->", "getNextClusterSucc", "(", ")", ",", "Cand", ".", "SU", "==", "DAG", "->", "getNextClusterSucc", "(", ")", ",", "TryCand", ",", "Cand", ",", "Cluster", ")", ")", "return", ";", "if", "(", "tryLess", "(", "TryCand", ".", "ResDelta", ".", "CritResources", ",", "Cand", ".", "ResDelta", ".", "CritResources", ",", "TryCand", ",", "Cand", ",", "ResourceReduce", ")", ")", "return", ";", "if", "(", "tryGreater", "(", "TryCand", ".", "ResDelta", ".", "DemandedResources", ",", "Cand", ".", "ResDelta", ".", "DemandedResources", ",", "TryCand", ",", "Cand", ",", "ResourceDemand", ")", ")", "return", ";", "if", "(", "Cand", ".", "Policy", ".", "ReduceLatency", "&&", "tryLatency", "(", "TryCand", ",", "Cand", ",", "Top", ")", ")", "{", "return", ";", "}", "if", "(", "TryCand", ".", "SU", "->", "NodeNum", "<", "Cand", ".", "SU", "->", "NodeNum", ")", "TryCand", ".", "Reason", "=", "NodeOrder", ";", "if", "(", "TryCand", ".", "Reason", "!=", "NodeOrder", "&&", "TryCand", ".", "Reason", "!=", "NoCand", ")", "return", ";", "if", "(", "biasAddiCandidate", "(", "Cand", ",", "TryCand", ")", ")", "return", ";", "}", "</s>" ]

[ "Apply", "a", "set", "of", "heuristics", "to", "a", "new", "candidate", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "HexagonTTIImpl", "::", "isLegalMaskedLoad", "(", "Type", "*", "DataType", ",", "Align", ")", "{", "return", "HexagonMaskedVMem", "&&", "ST", ".", "isTypeForHVX", "(", "DataType", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "machine_mode", "rs6000_preferred_simd_mode", "(", "scalar_mode", "mode", ")", "{", "if", "(", "TARGET_VSX", ")", "switch", "(", "mode", ")", "{", "case", "E_DFmode", ":", "return", "V2DFmode", ";", "default", ":", ";", "}", "if", "(", "TARGET_ALTIVEC", "||", "TARGET_VSX", ")", "switch", "(", "mode", ")", "{", "case", "E_SFmode", ":", "return", "V4SFmode", ";", "case", "E_TImode", ":", "return", "V1TImode", ";", "case", "E_DImode", ":", "return", "V2DImode", ";", "case", "E_SImode", ":", "return", "V4SImode", ";", "case", "E_HImode", ":", "return", "V8HImode", ";", "case", "E_QImode", ":", "return", "V16QImode", ";", "default", ":", ";", "}", "if", "(", "TARGET_PAIRED_FLOAT", "&&", "mode", "==", "SFmode", ")", "return", "V2SFmode", ";", "return", "word_mode", ";", "}", "</s>" ]

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

[ "rs6000" ]

[]

[ "<s>", "void", "AArch64AsmPrinter", "::", "emitStartOfAsmFile", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "TM", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "return", ";", "unsigned", "Flags", "=", "ELF", "::", "GNU_PROPERTY_AARCH64_FEATURE_1_BTI", "|", "ELF", "::", "GNU_PROPERTY_AARCH64_FEATURE_1_PAC", ";", "if", "(", "any_of", "(", "M", ",", "[", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "!", "F", ".", "isDeclaration", "(", ")", "&&", "!", "F", ".", "hasFnAttribute", "(", "\"branch-target-enforcement\"", ")", ";", "}", ")", ")", "{", "Flags", "&=", "~", "ELF", "::", "GNU_PROPERTY_AARCH64_FEATURE_1_BTI", ";", "}", "if", "(", "(", "Flags", "&", "ELF", "::", "GNU_PROPERTY_AARCH64_FEATURE_1_BTI", ")", "==", "0", "&&", "any_of", "(", "M", ",", "[", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "F", ".", "hasFnAttribute", "(", "\"branch-target-enforcement\"", ")", ";", "}", ")", ")", "{", "errs", "(", ")", "<<", "\"warning: some functions compiled with BTI and some compiled \"", "\"without BTI\\n\"", "<<", "\"warning: not setting BTI in feature flags\\n\"", ";", "}", "if", "(", "any_of", "(", "M", ",", "[", "]", "(", "const", "Function", "&", "F", ")", "{", "if", "(", "F", ".", "isDeclaration", "(", ")", ")", "return", "false", ";", "Attribute", "A", "=", "F", ".", "getFnAttribute", "(", "\"sign-return-address\"", ")", ";", "return", "!", "A", ".", "isStringAttribute", "(", ")", "||", "A", ".", "getValueAsString", "(", ")", "==", "\"none\"", ";", "}", ")", ")", "{", "Flags", "&=", "~", "ELF", "::", "GNU_PROPERTY_AARCH64_FEATURE_1_PAC", ";", "}", "if", "(", "Flags", "==", "0", ")", "return", ";", "MCSection", "*", "Cur", "=", "OutStreamer", "->", "getCurrentSectionOnly", "(", ")", ";", "MCSection", "*", "Nt", "=", "MMI", "->", "getContext", "(", ")", ".", "getELFSection", "(", "\".note.gnu.property\"", ",", "ELF", "::", "SHT_NOTE", ",", "ELF", "::", "SHF_ALLOC", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Nt", ")", ";", "emitAlignment", "(", "Align", "(", "8", ")", ")", ";", "OutStreamer", "->", "emitInt32", "(", "4", ")", ";", "OutStreamer", "->", "emitInt32", "(", "4", "*", "4", ")", ";", "OutStreamer", "->", "emitInt32", "(", "ELF", "::", "NT_GNU_PROPERTY_TYPE_0", ")", ";", "OutStreamer", "->", "emitBytes", "(", "StringRef", "(", "\"GNU\"", ",", "4", ")", ")", ";", "OutStreamer", "->", "emitInt32", "(", "ELF", "::", "GNU_PROPERTY_AARCH64_FEATURE_1_AND", ")", ";", "OutStreamer", "->", "emitInt32", "(", "4", ")", ";", "OutStreamer", "->", "emitInt32", "(", "Flags", ")", ";", "OutStreamer", "->", "emitInt32", "(", "0", ")", ";", "OutStreamer", "->", "endSection", "(", "Nt", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Cur", ")", ";", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "start", "of", "their", "file", "." ]

[ "AArch64", "AArch64", "\"branch-target-enforcement\"", "0", "\"branch-target-enforcement\"", "\"warning: some functions compiled with BTI and some compiled \"", "\"without BTI\\n\"", "\"warning: not setting BTI in feature flags\\n\"", "\"sign-return-address\"", "\"none\"", "0", "\".note.gnu.property\"", "8", "4", "4", "4", "\"GNU\"", "4", "4", "0" ]

[]

[ "<s>", "bool", "use_simple_return_p", "(", "void", ")", "{", "arm_stack_offsets", "*", "offsets", ";", "offsets", "=", "arm_get_frame_offsets", "(", ")", ";", "return", "offsets", "->", "outgoing_args", "!=", "0", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "we", "should", "try", "to", "use", "a", "simple_return", "insn", ",", "i.e", ".", "perform", "shrink-wrapping", "if", "possible", ".", "This", "is", "the", "case", "if", "we", "need", "to", "emit", "a", "prologue", ",", "which", "we", "can", "test", "by", "looking", "at", "the", "offsets", "." ]

[ "arm", "0" ]

[]

[ "<s>", "void", "ScheduleDAGPostRA", "::", "placeDebugValues", "(", ")", "{", "if", "(", "FirstDbgValue", ")", "{", "BB", "->", "splice", "(", "RegionBegin", ",", "BB", ",", "FirstDbgValue", ")", ";", "RegionBegin", "=", "FirstDbgValue", ";", "}", "for", "(", "std", "::", "vector", "<", "std", "::", "pair", "<", "MachineInstr", "*", ",", "MachineInstr", "*", ">", ">", "::", "iterator", "DI", "=", "DbgValues", ".", "end", "(", ")", ",", "DE", "=", "DbgValues", ".", "begin", "(", ")", ";", "DI", "!=", "DE", ";", "--", "DI", ")", "{", "std", "::", "pair", "<", "MachineInstr", "*", ",", "MachineInstr", "*", ">", "P", "=", "*", "std", "::", "prev", "(", "DI", ")", ";", "MachineInstr", "*", "DbgValue", "=", "P", ".", "first", ";", "MachineBasicBlock", "::", "instr_iterator", "OrigPrevMI", "(", "P", ".", "second", ")", ";", "while", "(", "OrigPrevMI", "->", "isBundledWithSucc", "(", ")", ")", "{", "OrigPrevMI", "++", ";", "}", "moveInstruction", "(", "DbgValue", "->", "getIterator", "(", ")", ",", "++", "OrigPrevMI", ")", ";", "}", "DbgValues", ".", "clear", "(", ")", ";", "FirstDbgValue", "=", "NULL", ";", "}", "</s>" ]

[ "Reinsert", "debug_values", "recorded", "in", "ScheduleDAGInstrs", ":", ":DbgValues", "." ]

[ "Patmos" ]

[]

[ "<s>", "enum", "reg_class", "mep_preferred_reload_class", "(", "rtx", "x", ",", "enum", "reg_class", "rclass", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST_INT", ":", "if", "(", "INTVAL", "(", "x", ")", ">=", "0x10000", "&&", "INTVAL", "(", "x", ")", "<", "0x01000000", "&&", "(", "INTVAL", "(", "x", ")", "&", "0xffff", ")", "!=", "0", "&&", "reg_class_subset_p", "(", "TPREL_REGS", ",", "rclass", ")", ")", "rclass", "=", "TPREL_REGS", ";", "break", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "if", "(", "mep_section_tag", "(", "x", ")", "!=", "'f'", "&&", "reg_class_subset_p", "(", "TPREL_REGS", ",", "rclass", ")", ")", "rclass", "=", "TPREL_REGS", ";", "break", ";", "default", ":", "break", ";", "}", "return", "rclass", ";", "}", "</s>" ]

[ "Implement", "PREFERRED_RELOAD_CLASS", ".", "See", "whether", "X", "is", "a", "constant", "that", "can", "be", "moved", "directly", "into", "registers", "0", "to", "7", ",", "but", "not", "into", "the", "rest", ".", "If", "so", ",", "and", "if", "the", "required", "class", "includes", "registers", "0", "to", "7", ",", "restrict", "it", "to", "those", "registers", "." ]

[ "mep", "0x10000", "0x01000000", "0xffff", "0" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Remove sign extends\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Remove sign extends\"" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPreEmitPass", "(", ")", "{", "TargetPassConfig", "::", "addPreEmitPass", "(", ")", ";", "addPass", "(", "createWebAssemblyReplacePhysRegs", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyCallIndirectFixup", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createWebAssemblyPrepareForLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyOptimizeLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyStoreResults", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegStackify", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegColoring", "(", ")", ")", ";", "}", "addPass", "(", "createWebAssemblyFixIrreducibleControlFlow", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyExplicitLocals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLateEHPrepare", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyCFGSort", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyCFGStackify", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLowerBrUnless", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createWebAssemblyPeephole", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegNumbering", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "WebAssemblyAsmPrinter", "::", "emitGlobalVariable", "(", "const", "GlobalVariable", "*", "GV", ")", "{", "if", "(", "!", "WebAssembly", "::", "isWasmVarAddressSpace", "(", "GV", "->", "getAddressSpace", "(", ")", ")", ")", "{", "AsmPrinter", "::", "emitGlobalVariable", "(", "GV", ")", ";", "return", ";", "}", "assert", "(", "!", "GV", "->", "isThreadLocal", "(", ")", ")", ";", "MCSymbolWasm", "*", "Sym", "=", "cast", "<", "MCSymbolWasm", ">", "(", "getSymbol", "(", "GV", ")", ")", ";", "if", "(", "!", "Sym", "->", "getType", "(", ")", ")", "{", "SmallVector", "<", "MVT", ",", "1", ">", "VTs", ";", "Type", "*", "GlobalVT", "=", "GV", "->", "getValueType", "(", ")", ";", "if", "(", "Subtarget", ")", "{", "const", "WebAssemblyTargetLowering", "&", "TLI", "=", "*", "Subtarget", "->", "getTargetLowering", "(", ")", ";", "computeLegalValueVTs", "(", "TLI", ",", "GV", "->", "getParent", "(", ")", "->", "getContext", "(", ")", ",", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ",", "GlobalVT", ",", "VTs", ")", ";", "}", "WebAssembly", "::", "wasmSymbolSetType", "(", "Sym", ",", "GlobalVT", ",", "VTs", ")", ";", "}", "emitVisibility", "(", "Sym", ",", "GV", "->", "getVisibility", "(", ")", ",", "!", "GV", "->", "isDeclaration", "(", ")", ")", ";", "emitSymbolType", "(", "Sym", ")", ";", "if", "(", "GV", "->", "hasInitializer", "(", ")", ")", "{", "assert", "(", "getSymbolPreferLocal", "(", "*", "GV", ")", "==", "Sym", ")", ";", "emitLinkage", "(", "GV", ",", "Sym", ")", ";", "OutStreamer", "->", "emitLabel", "(", "Sym", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "}", "</s>" ]

[ "Emit", "the", "specified", "global", "variable", "to", "the", ".s", "file", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly::isWasmVarAddressSpace", "1", "WebAssembly", "WebAssembly::wasmSymbolSetType" ]

[]

[ "<s>", "void", "mmix_asm_output_def", "(", "FILE", "*", "stream", ",", "const", "char", "*", "name", ",", "const", "char", "*", "value", ")", "{", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\tIS \"", ")", ";", "assemble_name", "(", "stream", ",", "value", ")", ";", "fputc", "(", "'\\n'", ",", "stream", ")", ";", "}", "</s>" ]

[ "ASM_OUTPUT_DEF", "." ]

[ "mmix", "\"\\tIS \"" ]

[]

[ "<s>", "bool", "AArch64PostLegalizerLowering", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "FailedISel", ")", ")", "return", "false", ";", "assert", "(", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "Legalized", ")", "&&", "\"Expected a legalized function?\"", ")", ";", "auto", "*", "TPC", "=", "&", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "AArch64PostLegalizerLoweringInfo", "PCInfo", "(", "F", ".", "hasOptSize", "(", ")", ",", "F", ".", "hasMinSize", "(", ")", ")", ";", "Combiner", "C", "(", "PCInfo", ",", "TPC", ")", ";", "return", "C", ".", "combineMachineInstrs", "(", "MF", ",", "nullptr", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Expected a legalized function?\"", "AArch64" ]

[]

[ "<s>", "static", "bool", "avr_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "size", "==", "POINTER_SIZE", "/", "BITS_PER_UNIT", "&&", "aligned_p", "&&", "text_segment_operand", "(", "x", ",", "VOIDmode", ")", ")", "{", "fputs", "(", "\"\\t.word\\tgs(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\\n\"", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "else", "if", "(", "GET_MODE", "(", "x", ")", "==", "PSImode", ")", "{", "fputs", "(", "\"\\t.byte\\tlo8(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\"", "ASM_COMMENT_START", "\"need binutils PR13503\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.byte\\thi8(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\"", "ASM_COMMENT_START", "\"need binutils PR13503\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.byte\\thh8(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\"", "ASM_COMMENT_START", "\"need binutils PR13503\\n\"", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "else", "if", "(", "CONST_FIXED_P", "(", "x", ")", ")", "{", "unsigned", "n", ";", "for", "(", "n", "=", "0", ";", "n", "<", "size", ";", "n", "++", ")", "{", "rtx", "xn", "=", "simplify_gen_subreg", "(", "QImode", ",", "x", ",", "GET_MODE", "(", "x", ")", ",", "n", ")", ";", "default_assemble_integer", "(", "xn", ",", "1", ",", "aligned_p", ")", ";", "}", "return", "true", ";", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "assembling", "integer", "objects", ".", "The", "AVR", "version", "needs", "special", "handling", "for", "references", "to", "certain", "labels", "." ]

[ "avr", "\"\\t.word\\tgs(\"", "\")\\n\"", "\"\\t.byte\\tlo8(\"", "\")\"", "\"need binutils PR13503\\n\"", "\"\\t.byte\\thi8(\"", "\")\"", "\"need binutils PR13503\\n\"", "\"\\t.byte\\thh8(\"", "\")\"", "\"need binutils PR13503\\n\"", "0", "1" ]

[]

[ "<s>", "Register", "M88kRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "getFrameLowering", "(", "MF", ")", "->", "hasFP", "(", "MF", ")", ")", "return", "M88k", "::", "R30", ";", "return", "M88k", "::", "R31", ";", "}", "</s>" ]

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

[ "M88k", "M88k", "M88k::R30", "M88k::R31" ]

[]

[ "<s>", "void", "addPostRegAlloc", "(", ")", "override", "{", "if", "(", "getMipsSubtarget", "(", ")", ".", "isCheri", "(", ")", ")", "addPass", "(", "createCheriInvalidatePass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "const", "OR1KInstrInfo", "*", "getInstrInfo", "(", ")", "{", "return", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "shouldLocalize", "(", "const", "MachineInstr", "&", "MI", ",", "const", "TargetTransformInfo", "*", "TTI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_GLOBAL_VALUE", ":", "{", "const", "GlobalValue", "&", "GV", "=", "*", "MI", ".", "getOperand", "(", "1", ")", ".", "getGlobal", "(", ")", ";", "if", "(", "GV", ".", "isThreadLocal", "(", ")", "&&", "Subtarget", "->", "isTargetMachO", "(", ")", ")", "return", "false", ";", "break", ";", "}", "case", "AArch64", "::", "ADRP", ":", "case", "AArch64", "::", "G_ADD_LOW", ":", "return", "true", ";", "default", ":", "break", ";", "}", "return", "TargetLoweringBase", "::", "shouldLocalize", "(", "MI", ",", "TTI", ")", ";", "}", "</s>" ]

[ "Check", "whether", "or", "not", "MI", "needs", "to", "be", "moved", "close", "to", "its", "uses", "." ]

[ "AArch64", "AArch64", "1", "AArch64::ADRP", "AArch64::G_ADD_LOW" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "GCNHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "SIInstrInfo", "::", "isSMRD", "(", "*", "MI", ")", "&&", "checkSMRDHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "(", "SIInstrInfo", "::", "isVMEM", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isFLAT", "(", "*", "MI", ")", ")", "&&", "checkVMEMHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "SIInstrInfo", "::", "isVALU", "(", "*", "MI", ")", "&&", "checkVALUHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "SIInstrInfo", "::", "isDPP", "(", "*", "MI", ")", "&&", "checkDPPHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isDivFMas", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkDivFMasHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isRWLane", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkRWLaneHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isSGetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkGetRegHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isSSetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkSetRegHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isRFE", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkRFEHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "ST", ".", "hasReadM0MovRelInterpHazard", "(", ")", "&&", "(", "TII", ".", "isVINTRP", "(", "*", "MI", ")", "||", "isSMovRel", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "&&", "checkReadM0Hazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "ST", ".", "hasReadM0SendMsgHazard", "(", ")", "&&", "isSendMsgTraceDataOrGDS", "(", "*", "MI", ")", "&&", "checkReadM0Hazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", "&&", "checkInlineAsmHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "checkAnyInstHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "return", "NoHazard", ";", "}", "</s>" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

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

[]

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

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

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

[]

[ "<s>", "static", "inline", "int", "abi_default_cpu_arch", "(", "struct", "loongarch_abi", "abi", ")", "{", "switch", "(", "abi", ".", "base", ")", "{", "case", "ABI_BASE_LP64D", ":", "case", "ABI_BASE_LP64F", ":", "case", "ABI_BASE_LP64S", ":", "if", "(", "abi", ".", "ext", "==", "ABI_EXT_BASE", ")", "return", "CPU_LOONGARCH64", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "The", "behavior", "of", "this", "function", "should", "be", "consistent", "with", "config.gcc", "." ]

[ "loongarch" ]

[]

[ "<s>", "bool", "R600TargetLowering", "::", "canMergeStoresTo", "(", "unsigned", "AS", ",", "EVT", "MemVT", ",", "const", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "(", "AS", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", "||", "AS", "==", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ")", ")", "{", "return", "(", "MemVT", ".", "getSizeInBits", "(", ")", "<=", "32", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Returns", "if", "it", "'s", "reasonable", "to", "merge", "stores", "to", "MemVT", "size", "." ]

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

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "MachineInstr", "&", "MIa", ",", "MachineInstr", "&", "MIb", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "if", "(", "!", "MIa", ".", "hasOneMemOperand", "(", ")", "||", "!", "MIb", ".", "hasOneMemOperand", "(", ")", ")", "return", "false", ";", "MachineMemOperand", "*", "MMOa", "=", "*", "MIa", ".", "memoperands_begin", "(", ")", ";", "MachineMemOperand", "*", "MMOb", "=", "*", "MIb", ".", "memoperands_begin", "(", ")", ";", "const", "Value", "*", "VALa", "=", "MMOa", "->", "getValue", "(", ")", ";", "const", "Value", "*", "VALb", "=", "MMOb", "->", "getValue", "(", ")", ";", "bool", "SameVal", "=", "(", "VALa", "&&", "VALb", "&&", "(", "VALa", "==", "VALb", ")", ")", ";", "if", "(", "!", "SameVal", ")", "{", "const", "PseudoSourceValue", "*", "PSVa", "=", "MMOa", "->", "getPseudoValue", "(", ")", ";", "const", "PseudoSourceValue", "*", "PSVb", "=", "MMOb", "->", "getPseudoValue", "(", ")", ";", "if", "(", "PSVa", "&&", "PSVb", "&&", "(", "PSVa", "==", "PSVb", ")", ")", "SameVal", "=", "true", ";", "}", "if", "(", "SameVal", ")", "{", "int", "OffsetA", "=", "MMOa", "->", "getOffset", "(", ")", ",", "OffsetB", "=", "MMOb", "->", "getOffset", "(", ")", ";", "int", "WidthA", "=", "MMOa", "->", "getSize", "(", ")", ",", "WidthB", "=", "MMOb", "->", "getSize", "(", ")", ";", "int", "LowOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetA", ":", "OffsetB", ";", "int", "HighOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetB", ":", "OffsetA", ";", "int", "LowWidth", "=", "(", "LowOffset", "==", "OffsetA", ")", "?", "WidthA", ":", "WidthB", ";", "if", "(", "LowOffset", "+", "LowWidth", "<=", "HighOffset", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "int", "arm_sched_variable_issue", "(", "FILE", "*", ",", "int", ",", "rtx_insn", "*", "insn", ",", "int", "more", ")", "{", "if", "(", "DEBUG_INSN_P", "(", "insn", ")", ")", "return", "more", ";", "rtx_code", "code", "=", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", ";", "if", "(", "code", "==", "USE", "||", "code", "==", "CLOBBER", ")", "return", "more", ";", "if", "(", "get_attr_type", "(", "insn", ")", "==", "TYPE_NO_INSN", ")", "return", "more", ";", "return", "more", "-", "1", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCHED_VARIABLE_ISSUE", "." ]

[ "arm", "1" ]

[]

[ "<s>", "static", "bool", "ix86_valid_mask_cmp_mode", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_XOP", "&&", "!", "TARGET_AVX512F", ")", "return", "false", ";", "if", "(", "TARGET_AVX512FP16", "&&", "mode", "==", "HFmode", ")", "return", "true", ";", "if", "(", "!", "(", "TARGET_AVX512F", "&&", "VECTOR_MODE_P", "(", "mode", ")", ")", ")", "return", "false", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "int", "vector_size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "(", "inner_mode", "==", "QImode", "||", "inner_mode", "==", "HImode", ")", "&&", "!", "TARGET_AVX512BW", ")", "return", "false", ";", "return", "vector_size", "==", "64", "||", "TARGET_AVX512VL", ";", "}", "</s>" ]

[ "Return", "true", "if", "MODE", "is", "valid", "for", "vector", "compare", "to", "mask", "register", ",", "Same", "result", "for", "conditionl", "vector", "move", "with", "mask", "register", "." ]

[ "i386", "64" ]

[]

[ "<s>", "const", "AMDGPULibFunc", "::", "Param", "*", "AMDGPULibFunc", "::", "getLeads", "(", ")", "const", "{", "return", "cast", "<", "const", "AMDGPUMangledLibFunc", ">", "(", "Impl", ".", "get", "(", ")", ")", "->", "Leads", ";", "}", "</s>" ]

[ "Get", "leading", "parameters", "for", "mangled", "lib", "functions", "." ]

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

[]

[ "<s>", "int", "addr24_operand", "(", "rtx", "op", ",", "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", "&&", "satisfies_constraint_M", "(", "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", "0", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "bool", "M680x0InstrInfo", "::", "ExpandMOVEM", "(", "MachineInstrBuilder", "&", "MIB", ",", "const", "MCInstrDesc", "&", "Desc", ",", "bool", "isRM", ")", "const", "{", "int", "Reg", "=", "0", ",", "Offset", "=", "0", ",", "Base", "=", "0", ";", "auto", "XR32", "=", "RI", ".", "getRegClass", "(", "M680x0", "::", "XR32RegClassID", ")", ";", "auto", "DL", "=", "MIB", "->", "getDebugLoc", "(", ")", ";", "auto", "MI", "=", "MIB", ".", "getInstr", "(", ")", ";", "auto", "&", "MBB", "=", "*", "MIB", "->", "getParent", "(", ")", ";", "if", "(", "isRM", ")", "{", "Reg", "=", "MIB", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "Offset", "=", "MIB", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "Base", "=", "MIB", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "else", "{", "Offset", "=", "MIB", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "Base", "=", "MIB", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Reg", "=", "MIB", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "if", "(", "!", "XR32", "->", "contains", "(", "Reg", ")", ")", "{", "Reg", "=", "RI", ".", "getMatchingMegaReg", "(", "Reg", ",", "XR32", ")", ";", "assert", "(", "Reg", "&&", "\"Has not meaningful MEGA register\"", ")", ";", "}", "unsigned", "Mask", "=", "1", "<<", "RI", ".", "getSpillRegisterOrder", "(", "Reg", ")", ";", "if", "(", "isRM", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "Desc", ")", ".", "addImm", "(", "Mask", ")", ".", "addImm", "(", "Offset", ")", ".", "addReg", "(", "Base", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitDefine", ")", ".", "copyImplicitOps", "(", "*", "MIB", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "Desc", ")", ".", "addImm", "(", "Offset", ")", ".", "addReg", "(", "Base", ")", ".", "addImm", "(", "Mask", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Implicit", ")", ".", "copyImplicitOps", "(", "*", "MIB", ")", ";", "}", "MIB", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Expand", "all", "MOVEM", "pseudos", "into", "real", "MOVEMs", "." ]

[ "M680x0", "M680x0", "0", "0", "0", "M680x0::XR32RegClassID", "0", "1", "2", "0", "1", "2", "\"Has not meaningful MEGA register\"", "1" ]

[]

[ "<s>", "bool", "aarch64_sve_float_arith_immediate_p", "(", "rtx", "x", ",", "bool", "negate_p", ")", "{", "rtx", "elt", ";", "REAL_VALUE_TYPE", "r", ";", "if", "(", "!", "const_vec_duplicate_p", "(", "x", ",", "&", "elt", ")", "||", "!", "CONST_DOUBLE_P", "(", "elt", ")", ")", "return", "false", ";", "r", "=", "*", "CONST_DOUBLE_REAL_VALUE", "(", "elt", ")", ";", "if", "(", "negate_p", ")", "r", "=", "real_value_negate", "(", "&", "r", ")", ";", "if", "(", "real_equal", "(", "&", "r", ",", "&", "dconst1", ")", ")", "return", "true", ";", "if", "(", "real_equal", "(", "&", "r", ",", "&", "dconsthalf", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "immediate", "operand", "for", "an", "SVE", "FADD", "or", "FSUB", "instruction", ".", "Negate", "X", "first", "if", "NEGATE_P", "is", "true", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "bool", "abi_v4_pass_in_fpr", "(", "machine_mode", "mode", ")", "{", "if", "(", "!", "TARGET_FPRS", "||", "!", "TARGET_HARD_FLOAT", ")", "return", "false", ";", "if", "(", "TARGET_SINGLE_FLOAT", "&&", "mode", "==", "SFmode", ")", "return", "true", ";", "if", "(", "TARGET_DOUBLE_FLOAT", "&&", "mode", "==", "DFmode", ")", "return", "true", ";", "if", "(", "is_complex_IBM_long_double", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "FLOAT128_2REG_P", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Whether", "ABI_V4", "passes", "MODE", "args", "to", "a", "function", "in", "floating", "point", "registers", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "const", "Cpu0MCExpr", "*", "Cpu0MCExpr", "::", "create", "(", "const", "MCSymbol", "*", "Symbol", ",", "Cpu0MCExpr", "::", "Cpu0ExprKind", "Kind", ",", "MCContext", "&", "Ctx", ")", "{", "const", "MCSymbolRefExpr", "*", "MCSym", "=", "MCSymbolRefExpr", "::", "create", "(", "Symbol", ",", "MCSymbolRefExpr", "::", "VK_None", ",", "Ctx", ")", ";", "return", "new", "(", "Ctx", ")", "Cpu0MCExpr", "(", "Kind", ",", "MCSym", ")", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0" ]

[]

[ "<s>", "static", "void", "aarch64_init_rng_builtins", "(", "void", ")", "{", "tree", "unsigned_ptr_type", "=", "build_pointer_type", "(", "unsigned_intDI_type_node", ")", ";", "tree", "ftype", "=", "build_function_type_list", "(", "integer_type_node", ",", "unsigned_ptr_type", ",", "NULL", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_RNG_RNDR", "]", "=", "aarch64_general_add_builtin", "(", "\"__builtin_aarch64_rndr\"", ",", "ftype", ",", "AARCH64_BUILTIN_RNG_RNDR", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_RNG_RNDRRS", "]", "=", "aarch64_general_add_builtin", "(", "\"__builtin_aarch64_rndrrs\"", ",", "ftype", ",", "AARCH64_BUILTIN_RNG_RNDRRS", ")", ";", "}", "</s>" ]

[ "Add", "builtins", "for", "Random", "Number", "instructions", "." ]

[ "aarch64", "\"__builtin_aarch64_rndr\"", "\"__builtin_aarch64_rndrrs\"" ]

[]

[ "<s>", "bool", "SystemZPassConfig", "::", "addPreSched2", "(", ")", "{", "if", "(", "getSystemZTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "hasLoadStoreOnCond", "(", ")", ")", "addPass", "(", "&", "IfConverterID", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "PPCTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "CallOperandVal", "==", "NULL", ")", "return", "CW_Default", ";", "Type", "*", "type", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "if", "(", "StringRef", "(", "constraint", ")", "==", "\"wc\"", "&&", "type", "->", "isIntegerTy", "(", "1", ")", ")", "return", "CW_Register", ";", "switch", "(", "*", "constraint", ")", "{", "default", ":", "weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "info", ",", "constraint", ")", ";", "break", ";", "case", "'b'", ":", "if", "(", "type", "->", "isIntegerTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'f'", ":", "if", "(", "type", "->", "isFloatTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'d'", ":", "if", "(", "type", "->", "isDoubleTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'v'", ":", "if", "(", "type", "->", "isVectorTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'y'", ":", "weight", "=", "CW_Register", ";", "break", ";", "case", "'Z'", ":", "weight", "=", "CW_Memory", ";", "break", ";", "}", "return", "weight", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"wc\"", "1" ]

[]

[ "<s>", "void", "build", "(", "function_builder", "&", "b", ",", "const", "function_group_info", "&", "group", ")", "const", "override", "{", "auto_vec", "<", "tree", ">", "argument_types", ";", "function_instance", "function_instance", "(", "group", ".", "base_name", ",", "*", "group", ".", "base", ",", "*", "group", ".", "shape", ",", "group", ".", "ops_infos", ".", "types", "[", "0", "]", ",", "group", ".", "preds", "[", "0", "]", ",", "&", "group", ".", "ops_infos", ")", ";", "b", ".", "add_unique_function", "(", "function_instance", ",", "(", "*", "group", ".", "shape", ")", ",", "long_unsigned_type_node", ",", "argument_types", ")", ";", "}", "</s>" ]

[ "Build", "new", "chain", "starting", "from", "insn", "INSN_UID", "recursively", "adding", "all", "dependent", "uses", "and", "definitions", ".", "Return", "true", "if", "OK", ",", "false", "if", "the", "chain", "discovery", "was", "aborted", "." ]

[ "riscv", "0", "0" ]

[]

[ "<s>", "static", "void", "emitSPUpdate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "unsigned", "StackPtr", ",", "int64_t", "NumBytes", ",", "bool", "Is64Bit", ",", "const", "TargetInstrInfo", "&", "TII", ")", "{", "bool", "isSub", "=", "NumBytes", "<", "0", ";", "uint64_t", "Offset", "=", "isSub", "?", "-", "NumBytes", ":", "NumBytes", ";", "unsigned", "Opc", "=", "isSub", "?", "(", "(", "Offset", "<", "128", ")", "?", "(", "Is64Bit", "?", "X86", "::", "SUB64ri8", ":", "X86", "::", "SUB32ri8", ")", ":", "(", "Is64Bit", "?", "X86", "::", "SUB64ri32", ":", "X86", "::", "SUB32ri", ")", ")", ":", "(", "(", "Offset", "<", "128", ")", "?", "(", "Is64Bit", "?", "X86", "::", "ADD64ri8", ":", "X86", "::", "ADD32ri8", ")", ":", "(", "Is64Bit", "?", "X86", "::", "ADD64ri32", ":", "X86", "::", "ADD32ri", ")", ")", ";", "uint64_t", "Chunk", "=", "(", "1LL", "<<", "31", ")", "-", "1", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "while", "(", "Offset", ")", "{", "uint64_t", "ThisVal", "=", "(", "Offset", ">", "Chunk", ")", "?", "Chunk", ":", "Offset", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "ThisVal", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "Offset", "-=", "ThisVal", ";", "}", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "increment", "/", "decrement", "the", "stack", "pointer", "by", "a", "constant", "value", "." ]

[ "X86", "0", "128", "X86::SUB64ri8", "X86::SUB32ri8", "X86::SUB64ri32", "X86::SUB32ri", "128", "X86::ADD64ri8", "X86::ADD32ri8", "X86::ADD64ri32", "X86::ADD32ri", "1LL", "31", "1", "3" ]

[]

[ "<s>", "bool", "AMDGPUInstrInfo", "::", "hasLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "const", "MachineMemOperand", "*", "&", "MMO", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "If", "the", "specified", "machine", "instruction", "has", "a", "load", "from", "a", "stack", "slot", ",", "return", "true", "along", "with", "the", "FrameIndices", "of", "the", "loaded", "stack", "slot", "and", "the", "machine", "mem", "operands", "containing", "the", "reference", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "bool", "loongarch_valid_lo_sum_p", "(", "enum", "loongarch_symbol_type", "symbol_type", ",", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "int", "align", ",", "size", ";", "if", "(", "loongarch_symbol_insns", "(", "symbol_type", ",", "mode", ")", "==", "0", ")", "return", "false", ";", "if", "(", "!", "loongarch_split_symbol_type", "(", "symbol_type", ")", ")", "return", "false", ";", "if", "(", "mode", "==", "BLKmode", ")", "{", "rtx", "offset", ";", "split_const", "(", "x", ",", "&", "x", ",", "&", "offset", ")", ";", "if", "(", "!", "SYMBOL_REF_P", "(", "x", ")", ")", "return", "false", ";", "align", "=", "(", "SYMBOL_REF_DECL", "(", "x", ")", "?", "DECL_ALIGN", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", ":", "1", ")", ";", "size", "=", "(", "SYMBOL_REF_DECL", "(", "x", ")", "&&", "DECL_SIZE", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", "?", "tree_to_uhwi", "(", "DECL_SIZE", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", ")", ":", "2", "*", "BITS_PER_WORD", ")", ";", "}", "else", "{", "align", "=", "GET_MODE_ALIGNMENT", "(", "mode", ")", ";", "size", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "}", "if", "(", "size", ">", "BITS_PER_WORD", "&&", "(", "!", "TARGET_STRICT_ALIGN", "||", "size", ">", "align", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "LO_SUM", "can", "address", "a", "value", "of", "mode", "MODE", "when", "the", "LO_SUM", "symbol", "has", "type", "SYMBOL_TYPE", "." ]

[ "loongarch", "0", "1", "2" ]

[]

[ "<s>", "bool", "AMDGPUAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "AMDGPUSubtarget", "&", "STM", "=", "TM", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "STM", ".", "dumpCode", "(", ")", ")", "{", "MF", ".", "dump", "(", ")", ";", "}", "SetupMachineFunction", "(", "MF", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getTextSection", "(", ")", ")", ";", "if", "(", "STM", ".", "device", "(", ")", "->", "getGeneration", "(", ")", ">", "AMDGPUDeviceInfo", "::", "HD6XXX", ")", "{", "EmitProgramInfo", "(", "MF", ")", ";", "}", "EmitFunctionBody", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "AMDGPUDeviceInfo::HD6XXX" ]

[]