Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "void", "add_attribute", "(", "const", "char", "*", "mode", ",", "tree", "*", "attributes", ")", "{", "size_t", "len", "=", "strlen", "(", "mode", ")", ";", "tree", "value", "=", "build_string", "(", "len", ",", "mode", ")", ";", "TREE_TYPE", "(", "value", ")", "=", "build_array_type", "(", "char_type_node", ",", "build_index_type", "(", "size_int", "(", "len", ")", ")", ")", ";", "*", "attributes", "=", "tree_cons", "(", "get_identifier", "(", "\"target\"", ")", ",", "build_tree_list", "(", "NULL_TREE", ",", "value", ")", ",", "*", "attributes", ")", ";", "}", "</s>" ]

[ "Add", "attribute", "NAME", "to", "ATTRS", "." ]

[ "arm", "\"target\"" ]

[]

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

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

[ "ARM", "0" ]

[]

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

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

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

[]

[ "<s>", "unsigned", "char", "AArch64Subtarget", "::", "ClassifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "&&", "isTargetMachO", "(", ")", ")", "return", "AArch64II", "::", "MO_GOT", ";", "if", "(", "!", "TM", ".", "shouldAssumeDSOLocal", "(", "*", "GV", "->", "getParent", "(", ")", ",", "GV", ")", ")", "{", "if", "(", "GV", "->", "hasDLLImportStorageClass", "(", ")", ")", "return", "AArch64II", "::", "MO_GOT", "|", "AArch64II", "::", "MO_DLLIMPORT", ";", "if", "(", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "return", "AArch64II", "::", "MO_GOT", "|", "AArch64II", "::", "MO_COFFSTUB", ";", "return", "AArch64II", "::", "MO_GOT", ";", "}", "if", "(", "(", "useSmallAddressing", "(", ")", "||", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Tiny", ")", "&&", "GV", "->", "hasExternalWeakLinkage", "(", ")", ")", "return", "AArch64II", "::", "MO_GOT", ";", "return", "AArch64II", "::", "MO_NO_FLAG", ";", "}", "</s>" ]

[ "ClassifyGlobalReference", "-", "Find", "the", "target", "operand", "flags", "that", "describe", "how", "a", "global", "value", "should", "be", "referenced", "for", "the", "current", "subtarget", "." ]

[ "AArch64", "AArch64", "AArch64II::MO_GOT", "AArch64II::MO_GOT", "AArch64II::MO_DLLIMPORT", "AArch64II::MO_GOT", "AArch64II::MO_COFFSTUB", "AArch64II::MO_GOT", "AArch64II::MO_GOT", "AArch64II::MO_NO_FLAG" ]

[]

[ "<s>", "static", "const", "char", "*", "shift_op", "(", "rtx", "op", ",", "HOST_WIDE_INT", "*", "amountp", ")", "{", "const", "char", "*", "mnem", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "switch", "(", "code", ")", "{", "case", "ROTATE", ":", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "{", "output_operand_lossage", "(", "\"invalid shift operand\"", ")", ";", "return", "NULL", ";", "}", "code", "=", "ROTATERT", ";", "*", "amountp", "=", "32", "-", "INTVAL", "(", "XEXP", "(", "op", ",", "1", ")", ")", ";", "mnem", "=", "\"ror\"", ";", "break", ";", "case", "ASHIFT", ":", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "case", "ROTATERT", ":", "mnem", "=", "arm_shift_nmem", "(", "code", ")", ";", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "{", "*", "amountp", "=", "INTVAL", "(", "XEXP", "(", "op", ",", "1", ")", ")", ";", "}", "else", "if", "(", "REG_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "{", "*", "amountp", "=", "-", "1", ";", "return", "mnem", ";", "}", "else", "{", "output_operand_lossage", "(", "\"invalid shift operand\"", ")", ";", "return", "NULL", ";", "}", "break", ";", "case", "MULT", ":", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "{", "output_operand_lossage", "(", "\"invalid shift operand\"", ")", ";", "return", "NULL", ";", "}", "*", "amountp", "=", "INTVAL", "(", "XEXP", "(", "op", ",", "1", ")", ")", "&", "0xFFFFFFFF", ";", "if", "(", "*", "amountp", "&", "(", "*", "amountp", "-", "1", ")", ")", "{", "output_operand_lossage", "(", "\"invalid shift operand\"", ")", ";", "return", "NULL", ";", "}", "*", "amountp", "=", "int_log2", "(", "*", "amountp", ")", ";", "return", "ARM_LSL_NAME", ";", "default", ":", "output_operand_lossage", "(", "\"invalid shift operand\"", ")", ";", "return", "NULL", ";", "}", "if", "(", "code", "==", "ROTATERT", ")", "*", "amountp", "&=", "31", ";", "else", "if", "(", "*", "amountp", "!=", "(", "*", "amountp", "&", "31", ")", ")", "{", "if", "(", "code", "==", "ASHIFT", ")", "mnem", "=", "\"lsr\"", ";", "*", "amountp", "=", "32", ";", "}", "if", "(", "*", "amountp", "==", "0", ")", "return", "NULL", ";", "return", "mnem", ";", "}", "</s>" ]

[ "Ensure", "valid", "constant", "shifts", "and", "return", "the", "appropriate", "shift", "mnemonic", "for", "the", "operation", "code", ".", "The", "returned", "result", "should", "not", "be", "overwritten", ".", "OP", "is", "the", "rtx", "code", "of", "the", "shift", ".", "On", "exit", ",", "*", "AMOUNTP", "will", "be", "-1", "if", "the", "shift", "is", "by", "a", "register", ",", "or", "a", "constant", "shift", "." ]

[ "arm", "1", "\"invalid shift operand\"", "32", "1", "\"ror\"", "1", "1", "1", "1", "\"invalid shift operand\"", "1", "\"invalid shift operand\"", "1", "0xFFFFFFFF", "1", "\"invalid shift operand\"", "\"invalid shift operand\"", "31", "31", "\"lsr\"", "32", "0" ]

[]

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

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "void", "mn10300_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "cum", "->", "nbytes", "+=", "(", "mode", "!=", "BLKmode", "?", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "3", ")", "&", "~", "3", ":", "(", "int_size_in_bytes", "(", "type", ")", "+", "3", ")", "&", "~", "3", ")", ";", "}", "</s>" ]

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

[ "mn10300", "3", "3", "3", "3" ]

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "assert", "(", "(", "Subtarget", "->", "hasMultivalue", "(", ")", "||", "Outs", ".", "size", "(", ")", "<=", "1", ")", "&&", "\"MVP WebAssembly can only return up to one value\"", ")", ";", "if", "(", "!", "callingConvSupported", "(", "CallConv", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support non-C calling conventions\"", ")", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "RetOps", ".", "append", "(", "OutVals", ".", "begin", "(", ")", ",", "OutVals", ".", "end", "(", ")", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "RETURN", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "for", "(", "const", "ISD", "::", "OutputArg", "&", "Out", ":", "Outs", ")", "{", "assert", "(", "!", "Out", ".", "Flags", ".", "isByVal", "(", ")", "&&", "\"byval is not valid for return values\"", ")", ";", "assert", "(", "!", "Out", ".", "Flags", ".", "isNest", "(", ")", "&&", "\"nest is not valid for return values\"", ")", ";", "assert", "(", "Out", ".", "IsFixed", "&&", "\"non-fixed return value is not valid\"", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInAlloca", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented inalloca results\"", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInConsecutiveRegs", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs results\"", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInConsecutiveRegsLast", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs last results\"", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "WebAssembly", "WebAssembly", "ISD::OutputArg", "1", "\"MVP WebAssembly can only return up to one value\"", "\"WebAssembly doesn't support non-C calling conventions\"", "4", "1", "WebAssemblyISD::RETURN", "MVT::Other", "ISD::OutputArg", "\"byval is not valid for return values\"", "\"nest is not valid for return values\"", "\"non-fixed return value is not valid\"", "\"WebAssembly hasn't implemented inalloca results\"", "\"WebAssembly hasn't implemented cons regs results\"", "\"WebAssembly hasn't implemented cons regs last results\"" ]

[]

[ "<s>", "const", "RISCVSubtarget", "*", "RISCVTargetMachine", "::", "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", ";", "std", "::", "string", "Key", "=", "CPU", "+", "FS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "RISCVSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "Options", ".", "MCOptions", ".", "getABIName", "(", ")", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addCodeGenPrepare", "(", ")", "{", "TargetPassConfig", "::", "addCodeGenPrepare", "(", ")", ";", "if", "(", "EnableLoadStoreVectorizer", ")", "addPass", "(", "createLoadStoreVectorizerPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Add", "pass", "to", "prepare", "the", "LLVM", "IR", "for", "code", "generation", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "rtx", "nios2_split_plus_large_constant", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "temp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "op0", "=", "force_reg", "(", "Pmode", ",", "op0", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "temp", ",", "gen_rtx_HIGH", "(", "Pmode", ",", "copy_rtx", "(", "op1", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "temp", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "op0", ",", "temp", ")", ")", ")", ";", "return", "gen_rtx_LO_SUM", "(", "Pmode", ",", "temp", ",", "copy_rtx", "(", "op1", ")", ")", ";", "}", "</s>" ]

[ "Split", "an", "RTX", "of", "the", "form", "(", "plus", "op0", "op1", ")", "where", "op1", "is", "a", "large", "constant", "into", "(", "set", "temp", "(", "high", "op1", ")", ")", "(", "set", "temp", "(", "plus", "op0", "temp", ")", ")", "(", "lo_sum", "temp", "op1", ")", "returning", "the", "lo_sum", "expression", "as", "the", "value", "." ]

[ "nios2" ]

[]

[ "<s>", "int", "s390_single_part", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ",", "enum", "machine_mode", "part_mode", ",", "int", "def", ")", "{", "unsigned", "HOST_WIDE_INT", "value", "=", "0", ";", "int", "n_parts", "=", "GET_MODE_SIZE", "(", "mode", ")", "/", "GET_MODE_SIZE", "(", "part_mode", ")", ";", "unsigned", "HOST_WIDE_INT", "part_mask", "=", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "GET_MODE_BITSIZE", "(", "part_mode", ")", ")", "-", "1", ";", "int", "i", ",", "part", "=", "-", "1", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "CONST_INT", ")", "return", "-", "1", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_parts", ";", "i", "++", ")", "{", "if", "(", "i", "==", "0", ")", "value", "=", "(", "unsigned", "HOST_WIDE_INT", ")", "INTVAL", "(", "op", ")", ";", "else", "value", ">>=", "GET_MODE_BITSIZE", "(", "part_mode", ")", ";", "if", "(", "(", "value", "&", "part_mask", ")", "!=", "(", "def", "&", "part_mask", ")", ")", "{", "if", "(", "part", "!=", "-", "1", ")", "return", "-", "1", ";", "else", "part", "=", "i", ";", "}", "}", "return", "part", "==", "-", "1", "?", "-", "1", ":", "n_parts", "-", "1", "-", "part", ";", "}", "</s>" ]

[ "If", "OP", "is", "an", "integer", "constant", "of", "mode", "MODE", "with", "exactly", "one", "part", "of", "mode", "PART_MODE", "unequal", "to", "DEF", ",", "return", "the", "number", "of", "that", "part", ".", "Otherwise", ",", "return", "-1", "." ]

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

[]

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

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

[ "SNES", "SNES" ]

[]

[ "<s>", "unsigned", "AVRInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "{", "const", "MCInstrDesc", "&", "Desc", "=", "get", "(", "Opcode", ")", ";", "return", "Desc", ".", "getSize", "(", ")", ";", "}", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "0", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "AVRTargetMachine", "&", "TM", "=", "static_cast", "<", "const", "AVRTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "return", "TII", ".", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "TM", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

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

[]

[ "<s>", "bool", "AArch64CompressJumpTables", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MFIn", ")", "{", "bool", "Changed", "=", "false", ";", "MF", "=", "&", "MFIn", ";", "const", "auto", "&", "ST", "=", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "if", "(", "ST", ".", "force32BitJumpTables", "(", ")", "&&", "!", "MF", "->", "getFunction", "(", ")", ".", "hasMinSize", "(", ")", ")", "return", "false", ";", "scanFunction", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "*", "MF", ")", "{", "int", "Offset", "=", "BlockInfo", "[", "MBB", ".", "getNumber", "(", ")", "]", ";", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "Changed", "|=", "compressJumpTable", "(", "MI", ",", "Offset", ")", ";", "Offset", "+=", "TII", "->", "getInstSizeInBytes", "(", "MI", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "rtx", "loongarch_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "rtx", "base", ",", "addr", ";", "HOST_WIDE_INT", "offset", ";", "if", "(", "loongarch_tls_symbol_p", "(", "x", ")", ")", "return", "loongarch_legitimize_tls_address", "(", "x", ")", ";", "if", "(", "loongarch_split_symbol", "(", "NULL", ",", "x", ",", "mode", ",", "&", "addr", ")", ")", "return", "loongarch_force_address", "(", "addr", ",", "mode", ")", ";", "loongarch_split_plus", "(", "x", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "offset", "!=", "0", ")", "{", "if", "(", "!", "loongarch_valid_base_register_p", "(", "base", ",", "mode", ",", "false", ")", ")", "base", "=", "copy_to_mode_reg", "(", "Pmode", ",", "base", ")", ";", "addr", "=", "loongarch_add_offset", "(", "NULL", ",", "base", ",", "offset", ")", ";", "return", "loongarch_force_address", "(", "addr", ",", "mode", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "This", "function", "is", "used", "to", "implement", "LEGITIMIZE_ADDRESS", ".", "If", "X", "can", "be", "legitimized", "in", "a", "way", "that", "the", "generic", "machinery", "might", "not", "expect", ",", "return", "a", "new", "address", ",", "otherwise", "return", "NULL", ".", "MODE", "is", "the", "mode", "of", "the", "memory", "being", "accessed", "." ]

[ "loongarch", "0" ]

[]

[ "<s>", "const", "char", "*", "avr_out_round", "(", "rtx_insn", "*", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "*", "xop", ",", "int", "*", "plen", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "xop", "[", "0", "]", ")", ";", "machine_mode", "imode", "=", "int_mode_for_mode", "(", "mode", ")", ";", "int", "fbit", "=", "(", "int", ")", "GET_MODE_FBIT", "(", "mode", ")", ";", "double_int", "i_add", "=", "double_int_zero", ".", "set_bit", "(", "fbit", "-", "1", "-", "INTVAL", "(", "xop", "[", "2", "]", ")", ")", ";", "wide_int", "wi_add", "=", "wi", "::", "set_bit_in_zero", "(", "fbit", "-", "1", "-", "INTVAL", "(", "xop", "[", "2", "]", ")", ",", "GET_MODE_PRECISION", "(", "imode", ")", ")", ";", "int", "len_add", "=", "0", ",", "*", "plen_add", "=", "plen", "?", "&", "len_add", ":", "NULL", ";", "int", "len_and", "=", "0", ",", "*", "plen_and", "=", "plen", "?", "&", "len_and", ":", "NULL", ";", "rtx", "xadd", "=", "const_fixed_from_double_int", "(", "i_add", ",", "mode", ")", ";", "rtx", "xpattern", ",", "xsrc", ",", "op", "[", "4", "]", ";", "xsrc", "=", "SIGNED_FIXED_POINT_MODE_P", "(", "mode", ")", "?", "gen_rtx_SS_PLUS", "(", "mode", ",", "xop", "[", "1", "]", ",", "xadd", ")", ":", "gen_rtx_US_PLUS", "(", "mode", ",", "xop", "[", "1", "]", ",", "xadd", ")", ";", "xpattern", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "xop", "[", "0", "]", ",", "xsrc", ")", ";", "op", "[", "0", "]", "=", "xop", "[", "0", "]", ";", "op", "[", "1", "]", "=", "xop", "[", "1", "]", ";", "op", "[", "2", "]", "=", "xadd", ";", "avr_out_plus", "(", "xpattern", ",", "op", ",", "plen_add", ",", "NULL", ",", "false", ")", ";", "avr_asm_len", "(", "\"rjmp 1f\"", "CR_TAB", "\"0:\"", ",", "NULL", ",", "plen_add", ",", "1", ")", ";", "rtx", "xreg", "=", "simplify_gen_subreg", "(", "imode", ",", "xop", "[", "0", "]", ",", "mode", ",", "0", ")", ";", "rtx", "xmask", "=", "immed_wide_int_const", "(", "-", "wi_add", "-", "wi_add", ",", "imode", ")", ";", "xpattern", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "xreg", ",", "gen_rtx_AND", "(", "imode", ",", "xreg", ",", "xmask", ")", ")", ";", "op", "[", "0", "]", "=", "xreg", ";", "op", "[", "1", "]", "=", "xreg", ";", "op", "[", "2", "]", "=", "xmask", ";", "op", "[", "3", "]", "=", "gen_rtx_SCRATCH", "(", "QImode", ")", ";", "avr_out_bitop", "(", "xpattern", ",", "op", ",", "plen_and", ")", ";", "avr_asm_len", "(", "\"1:\"", ",", "NULL", ",", "plen", ",", "0", ")", ";", "if", "(", "plen", ")", "*", "plen", "=", "len_add", "+", "len_and", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "fixed-point", "rounding", ".", "XOP", "[", "0", "]", "=", "XOP", "[", "1", "]", "is", "the", "operand", "to", "round", ".", "XOP", "[", "2", "]", "is", "the", "rounding", "point", ",", "a", "CONST_INT", ".", "The", "function", "prints", "the", "instruction", "sequence", "if", "PLEN", "=", "NULL", "and", "computes", "the", "length", "in", "words", "of", "the", "sequence", "if", "PLEN", "!", "=", "NULL", ".", "Most", "of", "this", "function", "deals", "with", "preparing", "operands", "for", "calls", "to", "`", "avr_out_plus", "'", "and", "`", "avr_out_bitop", "'", "." ]

[ "avr", "0", "1", "2", "1", "2", "0", "0", "4", "1", "1", "0", "0", "0", "1", "1", "2", "\"rjmp 1f\"", "\"0:\"", "1", "0", "0", "0", "1", "2", "3", "\"1:\"", "0", "\"\"" ]

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", "{", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", "&&", "isHsaAbiVersion3", "(", "getGlobalSTI", "(", ")", ")", ")", "{", "AsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", ";", "return", ";", "}", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "const", "GCNSubtarget", "&", "STM", "=", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "MFI", "->", "isEntryFunction", "(", ")", "&&", "STM", ".", "isAmdHsaOrMesa", "(", "MF", "->", "getFunction", "(", ")", ")", ")", "{", "SmallString", "<", "128", ">", "SymbolName", ";", "getNameWithPrefix", "(", "SymbolName", ",", "&", "MF", "->", "getFunction", "(", ")", ")", ",", "getTargetStreamer", "(", ")", "->", "EmitAMDGPUSymbolType", "(", "SymbolName", ",", "ELF", "::", "STT_AMDGPU_HSA_KERNEL", ")", ";", "}", "if", "(", "DumpCodeInstEmitter", ")", "{", "DisasmLines", ".", "push_back", "(", "MF", "->", "getName", "(", ")", ".", "str", "(", ")", "+", "\":\"", ")", ";", "DisasmLineMaxLen", "=", "std", "::", "max", "(", "DisasmLineMaxLen", ",", "DisasmLines", ".", "back", "(", ")", ".", "size", "(", ")", ")", ";", "HexLines", ".", "push_back", "(", "\"\"", ")", ";", "}", "AsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "SI", "SI", "128", "AMDGPU", "AMDGPU", "\":\"", "\"\"" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "RC", "->", "getID", "(", ")", "==", "X86", "::", "TILERegClassID", ")", "{", "unsigned", "Opc", "=", "X86", "::", "TILELOADD", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "Register", "VirtReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "X86", "::", "GR64_NOSPRegClass", ")", ";", "MachineInstr", "*", "NewMI", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DebugLoc", "(", ")", ",", "get", "(", "X86", "::", "MOV64ri", ")", ",", "VirtReg", ")", ".", "addImm", "(", "64", ")", ";", "NewMI", "=", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ";", "MachineOperand", "&", "MO", "=", "NewMI", "->", "getOperand", "(", "3", ")", ";", "MO", ".", "setReg", "(", "VirtReg", ")", ";", "MO", ".", "setIsKill", "(", "true", ")", ";", "}", "else", "if", "(", "RC", "->", "getID", "(", ")", "==", "X86", "::", "TILECFGRegClassID", ")", "{", "unsigned", "Opc", "=", "X86", "::", "PLDTILECFG", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ";", "}", "else", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "Alignment", "=", "std", "::", "max", "<", "uint32_t", ">", "(", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ",", "16", ")", ";", "bool", "isAligned", "=", "(", "Subtarget", ".", "getFrameLowering", "(", ")", "->", "getStackAlign", "(", ")", ">=", "Alignment", ")", "||", "RI", ".", "canRealignStack", "(", "MF", ")", ";", "unsigned", "Opc", "=", "getLoadRegOpcode", "(", "DestReg", ",", "RC", ",", "isAligned", ",", "Subtarget", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86::TILERegClassID", "X86::TILELOADD", "X86::GR64_NOSPRegClass", "X86::MOV64ri", "64", "3", "X86::TILECFGRegClassID", "X86::PLDTILECFG", "16" ]

[]

[ "<s>", "EVT", "MipsTargetLowering", "::", "getOptimalMemOpType", "(", "const", "MemOp", "&", "Op", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "{", "if", "(", "Subtarget", ".", "hasMips64", "(", ")", ")", "return", "MVT", "::", "i64", ";", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Mips Expand Pseudo\"", ";", "}", "</s>" ]

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

[ "Mips", "\"Mips Expand Pseudo\"" ]

[]

[ "<s>", "void", "AMDGPUCallLowering", "::", "splitToValueTypes", "(", "MachineIRBuilder", "&", "B", ",", "const", "ArgInfo", "&", "OrigArg", ",", "unsigned", "OrigArgIdx", ",", "SmallVectorImpl", "<", "ArgInfo", ">", "&", "SplitArgs", ",", "const", "DataLayout", "&", "DL", ",", "CallingConv", "::", "ID", "CallConv", ",", "SplitArgTy", "PerformArgSplit", ")", "const", "{", "const", "SITargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "SITargetLowering", ">", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "OrigArg", ".", "Ty", "->", "getContext", "(", ")", ";", "if", "(", "OrigArg", ".", "Ty", "->", "isVoidTy", "(", ")", ")", "return", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitVTs", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "OrigArg", ".", "Ty", ",", "SplitVTs", ")", ";", "assert", "(", "OrigArg", ".", "Regs", ".", "size", "(", ")", "==", "SplitVTs", ".", "size", "(", ")", ")", ";", "int", "SplitIdx", "=", "0", ";", "for", "(", "EVT", "VT", ":", "SplitVTs", ")", "{", "Register", "Reg", "=", "OrigArg", ".", "Regs", "[", "SplitIdx", "]", ";", "Type", "*", "Ty", "=", "VT", ".", "getTypeForEVT", "(", "Ctx", ")", ";", "LLT", "LLTy", "=", "getLLTForType", "(", "*", "Ty", ",", "DL", ")", ";", "if", "(", "OrigArgIdx", "==", "AttributeList", "::", "ReturnIndex", "&&", "VT", ".", "isScalarInteger", "(", ")", ")", "{", "unsigned", "ExtendOp", "=", "TargetOpcode", "::", "G_ANYEXT", ";", "if", "(", "OrigArg", ".", "Flags", "[", "0", "]", ".", "isSExt", "(", ")", ")", "{", "assert", "(", "OrigArg", ".", "Regs", ".", "size", "(", ")", "==", "1", "&&", "\"expect only simple return values\"", ")", ";", "ExtendOp", "=", "TargetOpcode", "::", "G_SEXT", ";", "}", "else", "if", "(", "OrigArg", ".", "Flags", "[", "0", "]", ".", "isZExt", "(", ")", ")", "{", "assert", "(", "OrigArg", ".", "Regs", ".", "size", "(", ")", "==", "1", "&&", "\"expect only simple return values\"", ")", ";", "ExtendOp", "=", "TargetOpcode", "::", "G_ZEXT", ";", "}", "EVT", "ExtVT", "=", "TLI", ".", "getTypeForExtReturn", "(", "Ctx", ",", "VT", ",", "extOpcodeToISDExtOpcode", "(", "ExtendOp", ")", ")", ";", "if", "(", "ExtVT", "!=", "VT", ")", "{", "VT", "=", "ExtVT", ";", "Ty", "=", "ExtVT", ".", "getTypeForEVT", "(", "Ctx", ")", ";", "LLTy", "=", "getLLTForType", "(", "*", "Ty", ",", "DL", ")", ";", "Reg", "=", "B", ".", "buildInstr", "(", "ExtendOp", ",", "{", "LLTy", "}", ",", "{", "Reg", "}", ")", ".", "getReg", "(", "0", ")", ";", "}", "}", "unsigned", "NumParts", "=", "TLI", ".", "getNumRegistersForCallingConv", "(", "Ctx", ",", "CallConv", ",", "VT", ")", ";", "MVT", "RegVT", "=", "TLI", ".", "getRegisterTypeForCallingConv", "(", "Ctx", ",", "CallConv", ",", "VT", ")", ";", "if", "(", "NumParts", "==", "1", ")", "{", "SplitArgs", ".", "emplace_back", "(", "Reg", ",", "Ty", ",", "OrigArg", ".", "Flags", ",", "OrigArg", ".", "IsFixed", ")", ";", "++", "SplitIdx", ";", "continue", ";", "}", "SmallVector", "<", "Register", ",", "8", ">", "SplitRegs", ";", "Type", "*", "PartTy", "=", "EVT", "(", "RegVT", ")", ".", "getTypeForEVT", "(", "Ctx", ")", ";", "LLT", "PartLLT", "=", "getLLTForType", "(", "*", "PartTy", ",", "DL", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "*", "B", ".", "getMRI", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumParts", ";", "++", "i", ")", "{", "Register", "PartReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "PartLLT", ")", ";", "SplitRegs", ".", "push_back", "(", "PartReg", ")", ";", "SplitArgs", ".", "emplace_back", "(", "ArrayRef", "<", "Register", ">", "(", "PartReg", ")", ",", "PartTy", ",", "OrigArg", ".", "Flags", ")", ";", "}", "PerformArgSplit", "(", "SplitRegs", ",", "Reg", ",", "LLTy", ",", "PartLLT", ",", "SplitIdx", ")", ";", "++", "SplitIdx", ";", "}", "}", "</s>" ]

[ "Break", "OrigArgInfo", "into", "one", "or", "more", "pieces", "the", "calling", "convention", "can", "process", ",", "returned", "in", "SplitArgs", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SI", "4", "0", "0", "1", "\"expect only simple return values\"", "0", "1", "\"expect only simple return values\"", "0", "1", "8", "0" ]

[]

[ "<s>", "bool", "function_checker", "::", "require_immediate_lane_index", "(", "unsigned", "int", "rel_argno", ",", "unsigned", "int", "group_size", ")", "{", "unsigned", "int", "argno", "=", "m_base_arg", "+", "rel_argno", ";", "if", "(", "!", "argument_exists_p", "(", "argno", ")", ")", "return", "true", ";", "machine_mode", "mode", "=", "TYPE_MODE", "(", "type_argument_type", "(", "m_fntype", ",", "argno", ")", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "mode", ")", ")", ";", "unsigned", "int", "nlanes", "=", "128", "/", "(", "group_size", "*", "GET_MODE_UNIT_BITSIZE", "(", "mode", ")", ")", ";", "return", "require_immediate_range", "(", "rel_argno", ",", "0", ",", "nlanes", "-", "1", ")", ";", "}", "</s>" ]

[ "Check", "that", "argument", "REL_ARGNO", "is", "suitable", "for", "indexing", "argument", "REL_ARGNO", "-", "1", ",", "in", "groups", "of", "GROUP_SIZE", "elements", ".", "REL_ARGNO", "counts", "from", "the", "end", "of", "the", "predication", "arguments", "." ]

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

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "SetupMachineFunction", "(", "MF", ")", ";", "if", "(", "Subtarget", "->", "isTargetCOFF", "(", ")", ")", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "O", "<<", "\"\\t.def\\t \"", "<<", "*", "CurrentFnSym", "<<", "\";\\t.scl\\t\"", "<<", "(", "F", "->", "hasInternalLinkage", "(", ")", "?", "COFF", "::", "C_STAT", ":", "COFF", "::", "C_EXT", ")", "<<", "\";\\t.type\\t\"", "<<", "(", "COFF", "::", "DT_FCN", "<<", "COFF", "::", "N_BTSHFT", ")", "<<", "\";\\t.endef\\n\"", ";", "}", "EmitFunctionHeader", "(", ")", ";", "EmitFunctionBody", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"\\t.def\\t \"", "\";\\t.scl\\t\"", "\";\\t.type\\t\"", "\";\\t.endef\\n\"" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "PPCTargetLowering", "::", "getScratchRegisters", "(", "CallingConv", "::", "ID", ")", "const", "{", "static", "const", "MCPhysReg", "ScratchRegs", "[", "]", "=", "{", "PPC", "::", "X12", ",", "PPC", "::", "LR8", ",", "PPC", "::", "CTR8", ",", "0", "}", ";", "return", "ScratchRegs", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::X12", "PPC::LR8", "PPC::CTR8", "0" ]

[]

[ "<s>", "unsigned", "X86RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "bool", "PPCAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'c'", ":", "break", ";", "case", "'L'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", "||", "OpNo", "+", "1", "==", "MI", "->", "getNumOperands", "(", ")", "||", "!", "MI", "->", "getOperand", "(", "OpNo", "+", "1", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "++", "OpNo", ";", "break", ";", "case", "'I'", ":", "if", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isImm", "(", ")", ")", "O", "<<", "\"i\"", ";", "return", "false", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "1", "0", "0", "1", "1", "\"i\"" ]

[]

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

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

[ "CellSPU", "MVT::i32" ]

[]

[ "<s>", "void", "HexagonInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "O", ",", "unsigned", "RegNo", ")", "const", "{", "O", "<<", "getRegName", "(", "RegNo", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "int", "s390_function_arg_size", "(", "enum", "machine_mode", "mode", ",", "tree", "type", ")", "{", "if", "(", "type", ")", "return", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "mode", "!=", "BLKmode", ")", "return", "GET_MODE_SIZE", "(", "mode", ")", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "size", "in", "bytes", "of", "a", "function", "argument", "of", "type", "TYPE", "and/or", "mode", "MODE", ".", "At", "least", "one", "of", "TYPE", "or", "MODE", "must", "be", "specified", "." ]

[ "s390" ]

[]

[ "<s>", "void", "RISCVRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected non-zero SPAdj value\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "RISCVInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "FrameReg", ";", "int", "Offset", "=", "getFrameLowering", "(", "MF", ")", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ")", "+", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "isInt", "<", "32", ">", "(", "Offset", ")", ")", "{", "report_fatal_error", "(", "\"Frame offsets outside of the signed 32-bit range not supported\"", ")", ";", "}", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "bool", "FrameRegIsKill", "=", "false", ";", "if", "(", "!", "isInt", "<", "12", ">", "(", "Offset", ")", ")", "{", "assert", "(", "isInt", "<", "32", ">", "(", "Offset", ")", "&&", "\"Int32 expected\"", ")", ";", "Register", "ScratchReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "RISCV", "::", "GPRRegClass", ")", ";", "TII", "->", "movImm32", "(", "MBB", ",", "II", ",", "DL", ",", "ScratchReg", ",", "Offset", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", "->", "get", "(", "RISCV", "::", "ADD", ")", ",", "ScratchReg", ")", ".", "addReg", "(", "FrameReg", ")", ".", "addReg", "(", "ScratchReg", ",", "RegState", "::", "Kill", ")", ";", "Offset", "=", "0", ";", "FrameReg", "=", "ScratchReg", ";", "FrameRegIsKill", "=", "true", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ",", "false", ",", "FrameRegIsKill", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "0", "\"Unexpected non-zero SPAdj value\"", "RISCV", "RISCV", "1", "32", "\"Frame offsets outside of the signed 32-bit range not supported\"", "12", "32", "\"Int32 expected\"", "RISCV::GPRRegClass", "RISCV::ADD", "0", "1" ]

[]

[ "<s>", "void", "arm_print_tune_info", "(", "void", ")", "{", "asm_fprintf", "(", "asm_out_file", ",", "\"\\[email protected] parameters\\n\"", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t@constant_limit:\\t%d\\n\"", ",", "current_tune", "->", "constant_limit", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t@max_insns_skipped:\\t%d\\n\"", ",", "current_tune", "->", "max_insns_skipped", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t@num_prefetch_slots:\\t%d\\n\"", ",", "current_tune", "->", "num_prefetch_slots", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t@l1_cache_size:\\t%d\\n\"", ",", "current_tune", "->", "l1_cache_size", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t@l1_cache_line_size:\\t%d\\n\"", ",", "current_tune", "->", "l1_cache_line_size", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t@prefer_constant_pool:\\t%d\\n\"", ",", "(", "int", ")", "current_tune", "->", "prefer_constant_pool", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t@branch_cost:\\t(s:speed, p:predictable)\\n\"", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\\t\\ts&p\\tcost\\n\"", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\\t\\t00\\t%d\\n\"", ",", "current_tune", "->", "branch_cost", "(", "false", ",", "false", ")", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\\t\\t01\\t%d\\n\"", ",", "current_tune", "->", "branch_cost", "(", "false", ",", "true", ")", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\\t\\t10\\t%d\\n\"", ",", "current_tune", "->", "branch_cost", "(", "true", ",", "false", ")", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\\t\\t11\\t%d\\n\"", ",", "current_tune", "->", "branch_cost", "(", "true", ",", "true", ")", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t@prefer_ldrd_strd:\\t%d\\n\"", ",", "(", "int", ")", "current_tune", "->", "prefer_ldrd_strd", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t@logical_op_non_short_circuit:\\t[%d,%d]\\n\"", ",", "(", "int", ")", "current_tune", "->", "logical_op_non_short_circuit", "[", "0", "]", ",", "(", "int", ")", "current_tune", "->", "logical_op_non_short_circuit", "[", "1", "]", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t@prefer_neon_for_64bits:\\t%d\\n\"", ",", "(", "int", ")", "current_tune", "->", "prefer_neon_for_64bits", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t@disparage_flag_setting_t16_encodings:\\t%d\\n\"", ",", "(", "int", ")", "current_tune", "->", "disparage_flag_setting_t16_encodings", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t@disparage_partial_flag_setting_t16_encodings:\\t%d\\n\"", ",", "(", "int", ")", "current_tune", "->", "disparage_partial_flag_setting_t16_encodings", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t@string_ops_prefer_neon:\\t%d\\n\"", ",", "(", "int", ")", "current_tune", "->", "string_ops_prefer_neon", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t@max_insns_inline_memset:\\t%d\\n\"", ",", "current_tune", "->", "max_insns_inline_memset", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t@fuseable_ops:\\t%u\\n\"", ",", "current_tune", "->", "fuseable_ops", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t@sched_autopref:\\t%d\\n\"", ",", "(", "int", ")", "current_tune", "->", "sched_autopref", ")", ";", "}", "</s>" ]

[ "This", "function", "is", "used", "to", "print", "CPU", "tuning", "information", "as", "comment", "in", "assembler", "file", ".", "Pointers", "are", "not", "printed", "for", "now", "." ]

[ "arm", "\"\\[email protected] parameters\\n\"", "\"\\t\\t@constant_limit:\\t%d\\n\"", "\"\\t\\t@max_insns_skipped:\\t%d\\n\"", "\"\\t\\t@num_prefetch_slots:\\t%d\\n\"", "\"\\t\\t@l1_cache_size:\\t%d\\n\"", "\"\\t\\t@l1_cache_line_size:\\t%d\\n\"", "\"\\t\\t@prefer_constant_pool:\\t%d\\n\"", "\"\\t\\t@branch_cost:\\t(s:speed, p:predictable)\\n\"", "\"\\t\\t\\t\\ts&p\\tcost\\n\"", "\"\\t\\t\\t\\t00\\t%d\\n\"", "\"\\t\\t\\t\\t01\\t%d\\n\"", "\"\\t\\t\\t\\t10\\t%d\\n\"", "\"\\t\\t\\t\\t11\\t%d\\n\"", "\"\\t\\t@prefer_ldrd_strd:\\t%d\\n\"", "\"\\t\\t@logical_op_non_short_circuit:\\t[%d,%d]\\n\"", "0", "1", "\"\\t\\t@prefer_neon_for_64bits:\\t%d\\n\"", "\"\\t\\t@disparage_flag_setting_t16_encodings:\\t%d\\n\"", "\"\\t\\t@disparage_partial_flag_setting_t16_encodings:\\t%d\\n\"", "\"\\t\\t@string_ops_prefer_neon:\\t%d\\n\"", "\"\\t\\t@max_insns_inline_memset:\\t%d\\n\"", "\"\\t\\t@fuseable_ops:\\t%u\\n\"", "\"\\t\\t@sched_autopref:\\t%d\\n\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "const", "TargetRegisterClass", "*", ",", "uint8_t", ">", "X86TargetLowering", "::", "findRepresentativeClass", "(", "EVT", "VT", ")", "const", "{", "const", "TargetRegisterClass", "*", "RRC", "=", "0", ";", "uint8_t", "Cost", "=", "1", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "return", "TargetLowering", "::", "findRepresentativeClass", "(", "VT", ")", ";", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i64", ":", "RRC", "=", "(", "Subtarget", "->", "is64Bit", "(", ")", "?", "X86", "::", "GR64RegisterClass", ":", "X86", "::", "GR32RegisterClass", ")", ";", "break", ";", "case", "MVT", "::", "v8i8", ":", "case", "MVT", "::", "v4i16", ":", "case", "MVT", "::", "v2i32", ":", "case", "MVT", "::", "v1i64", ":", "RRC", "=", "X86", "::", "VR64RegisterClass", ";", "break", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "case", "MVT", "::", "v16i8", ":", "case", "MVT", "::", "v8i16", ":", "case", "MVT", "::", "v4i32", ":", "case", "MVT", "::", "v2i64", ":", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v2f64", ":", "case", "MVT", "::", "v32i8", ":", "case", "MVT", "::", "v8i32", ":", "case", "MVT", "::", "v4i64", ":", "case", "MVT", "::", "v8f32", ":", "case", "MVT", "::", "v4f64", ":", "RRC", "=", "X86", "::", "VR128RegisterClass", ";", "break", ";", "}", "return", "std", "::", "make_pair", "(", "RRC", ",", "Cost", ")", ";", "}", "</s>" ]

[ "Return", "the", "largest", "legal", "super-reg", "register", "class", "of", "the", "register", "class", "for", "the", "specified", "type", "and", "its", "associated", "``", "cost", "''", "." ]

[ "X86", "X86", "0", "1", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::i64", "X86::GR64RegisterClass", "X86::GR32RegisterClass", "MVT::v8i8", "MVT::v4i16", "MVT::v2i32", "MVT::v1i64", "X86::VR64RegisterClass", "MVT::f32", "MVT::f64", "MVT::v16i8", "MVT::v8i16", "MVT::v4i32", "MVT::v2i64", "MVT::v4f32", "MVT::v2f64", "MVT::v32i8", "MVT::v8i32", "MVT::v4i64", "MVT::v8f32", "MVT::v4f64", "X86::VR128RegisterClass" ]

[]

[ "<s>", "static", "void", "seh_cfa_offset", "(", "FILE", "*", "f", ",", "struct", "seh_frame_state", "*", "seh", ",", "rtx", "pat", ")", "{", "rtx", "dest", ",", "src", ";", "HOST_WIDE_INT", "reg_offset", ";", "dest", "=", "SET_DEST", "(", "pat", ")", ";", "src", "=", "SET_SRC", "(", "pat", ")", ";", "gcc_assert", "(", "MEM_P", "(", "dest", ")", ")", ";", "dest", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "if", "(", "REG_P", "(", "dest", ")", ")", "reg_offset", "=", "0", ";", "else", "{", "gcc_assert", "(", "GET_CODE", "(", "dest", ")", "==", "PLUS", ")", ";", "reg_offset", "=", "INTVAL", "(", "XEXP", "(", "dest", ",", "1", ")", ")", ";", "dest", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "}", "gcc_assert", "(", "dest", "==", "seh", "->", "cfa_reg", ")", ";", "seh_emit_save", "(", "f", ",", "seh", ",", "src", ",", "seh", "->", "cfa_offset", "-", "reg_offset", ")", ";", "}", "</s>" ]

[ "Process", "REG_CFA_OFFSET", "for", "SEH", "." ]

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

[]

[ "<s>", "void", "LEGInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "BuildMI", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "get", "(", "LEG", "::", "STR", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "LEG", "LEG", "LEG::STR", "0" ]

[]

[ "<s>", "const", "char", "*", "SparcTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "SPISD", "::", "CMPICC", ":", "return", "\"SPISD::CMPICC\"", ";", "case", "SPISD", "::", "CMPFCC", ":", "return", "\"SPISD::CMPFCC\"", ";", "case", "SPISD", "::", "BRICC", ":", "return", "\"SPISD::BRICC\"", ";", "case", "SPISD", "::", "BRXCC", ":", "return", "\"SPISD::BRXCC\"", ";", "case", "SPISD", "::", "BRFCC", ":", "return", "\"SPISD::BRFCC\"", ";", "case", "SPISD", "::", "SELECT_ICC", ":", "return", "\"SPISD::SELECT_ICC\"", ";", "case", "SPISD", "::", "SELECT_XCC", ":", "return", "\"SPISD::SELECT_XCC\"", ";", "case", "SPISD", "::", "SELECT_FCC", ":", "return", "\"SPISD::SELECT_FCC\"", ";", "case", "SPISD", "::", "Hi", ":", "return", "\"SPISD::Hi\"", ";", "case", "SPISD", "::", "Lo", ":", "return", "\"SPISD::Lo\"", ";", "case", "SPISD", "::", "FTOI", ":", "return", "\"SPISD::FTOI\"", ";", "case", "SPISD", "::", "ITOF", ":", "return", "\"SPISD::ITOF\"", ";", "case", "SPISD", "::", "CALL", ":", "return", "\"SPISD::CALL\"", ";", "case", "SPISD", "::", "RET_FLAG", ":", "return", "\"SPISD::RET_FLAG\"", ";", "case", "SPISD", "::", "GLOBAL_BASE_REG", ":", "return", "\"SPISD::GLOBAL_BASE_REG\"", ";", "case", "SPISD", "::", "FLUSHW", ":", "return", "\"SPISD::FLUSHW\"", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "0", "SPISD::CMPICC", "\"SPISD::CMPICC\"", "SPISD::CMPFCC", "\"SPISD::CMPFCC\"", "SPISD::BRICC", "\"SPISD::BRICC\"", "SPISD::BRXCC", "\"SPISD::BRXCC\"", "SPISD::BRFCC", "\"SPISD::BRFCC\"", "SPISD::SELECT_ICC", "\"SPISD::SELECT_ICC\"", "SPISD::SELECT_XCC", "\"SPISD::SELECT_XCC\"", "SPISD::SELECT_FCC", "\"SPISD::SELECT_FCC\"", "SPISD::Hi", "\"SPISD::Hi\"", "SPISD::Lo", "\"SPISD::Lo\"", "SPISD::FTOI", "\"SPISD::FTOI\"", "SPISD::ITOF", "\"SPISD::ITOF\"", "SPISD::CALL", "\"SPISD::CALL\"", "SPISD::RET_FLAG", "\"SPISD::RET_FLAG\"", "SPISD::GLOBAL_BASE_REG", "\"SPISD::GLOBAL_BASE_REG\"", "SPISD::FLUSHW", "\"SPISD::FLUSHW\"" ]

[]

[ "<s>", "bool", "AVRPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createAVRISelDag", "(", "getAVRTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "addPass", "(", "createAVRFrameAnalyzerPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "InstructionCost", "RISCVTTIImpl", "::", "getIntImmCost", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", "&&", "\"getIntImmCost can only estimate cost of materialising integers\"", ")", ";", "if", "(", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "const", "DataLayout", "&", "DL", "=", "getDataLayout", "(", ")", ";", "return", "RISCVMatInt", "::", "getIntMatCost", "(", "Imm", ",", "DL", ".", "getTypeSizeInBits", "(", "Ty", ")", ",", "getST", "(", ")", "->", "getFeatureBits", "(", ")", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "RISCV", "RISCV", "\"getIntImmCost can only estimate cost of materialising integers\"", "0", "RISCVMatInt::getIntMatCost" ]

[]

[ "<s>", "bool", "HexagonSubtarget", "::", "enableMachineScheduler", "(", ")", "const", "{", "if", "(", "DisableHexagonMISched", ".", "getNumOccurrences", "(", ")", ")", "return", "!", "DisableHexagonMISched", ";", "return", "true", ";", "}", "</s>" ]

[ "Enable", "the", "MachineScheduler", "pass", "for", "all", "X86", "subtargets", "." ]

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

[]

[ "<s>", "SDValue", "AlphaDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "unsigned", "GP", "=", "0", ";", "for", "(", "MachineRegisterInfo", "::", "livein_iterator", "ii", "=", "RegInfo", "->", "livein_begin", "(", ")", ",", "ee", "=", "RegInfo", "->", "livein_end", "(", ")", ";", "ii", "!=", "ee", ";", "++", "ii", ")", "if", "(", "ii", "->", "first", "==", "Alpha", "::", "R29", ")", "{", "GP", "=", "ii", "->", "second", ";", "break", ";", "}", "assert", "(", "GP", "&&", "\"GOT PTR not in liveins\"", ")", ";", "return", "CurDAG", "->", "getCopyFromReg", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "DebugLoc", "::", "getUnknownLoc", "(", ")", ",", "GP", ",", "MVT", "::", "i64", ")", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha", "0", "Alpha::R29", "\"GOT PTR not in liveins\"", "MVT::i64" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "Options", ".", "ThreadModel", "==", "ThreadModel", "::", "Single", ")", "{", "addPass", "(", "createLowerAtomicPass", "(", ")", ")", ";", "addPass", "(", "new", "StripThreadLocal", "(", ")", ")", ";", "}", "else", "{", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "}", "addPass", "(", "createWebAssemblyAddMissingPrototypes", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLowerGlobalDtors", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyFixFunctionBitcasts", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createWebAssemblyOptimizeReturned", "(", ")", ")", ";", "if", "(", "!", "EnableEmException", "&&", "TM", "->", "Options", ".", "ExceptionModel", "==", "ExceptionHandling", "::", "None", ")", "{", "addPass", "(", "createLowerInvokePass", "(", ")", ")", ";", "addPass", "(", "createUnreachableBlockEliminationPass", "(", ")", ")", ";", "}", "if", "(", "EnableEmException", "||", "EnableEmSjLj", ")", "addPass", "(", "createWebAssemblyLowerEmscriptenEHSjLj", "(", "EnableEmException", ",", "EnableEmSjLj", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

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

[]

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

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

[ "TVM", "\"TVM Prepare For LiveIntervals\"" ]

[]

[ "<s>", "void", "AMDGPUAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "case", "AMDGPU", "::", "fixup_si_sopp_br", ":", "{", "int64_t", "BrImm", "=", "(", "(", "int64_t", ")", "Value", "-", "4", ")", "/", "4", ";", "if", "(", "!", "isInt", "<", "16", ">", "(", "BrImm", ")", ")", "report_fatal_error", "(", "\"branch size exceeds simm16\"", ")", ";", "uint16_t", "*", "Dst", "=", "(", "uint16_t", "*", ")", "(", "Data", "+", "Fixup", ".", "getOffset", "(", ")", ")", ";", "*", "Dst", "=", "BrImm", ";", "break", ";", "}", "default", ":", "{", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::fixup_si_sopp_br", "4", "4", "16", "\"branch size exceeds simm16\"", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "static", "bool", "frv_regstate_conflict_p", "(", "regstate_t", "cond1", ",", "regstate_t", "cond2", ")", "{", "if", "(", "(", "cond1", "&", "REGSTATE_IF_EITHER", ")", "==", "0", "||", "(", "cond2", "&", "REGSTATE_IF_EITHER", ")", "==", "0", ")", "return", "true", ";", "if", "(", "(", "cond1", "&", "REGSTATE_CC_MASK", ")", "!=", "(", "cond2", "&", "REGSTATE_CC_MASK", ")", ")", "return", "true", ";", "if", "(", "(", "cond1", "&", "cond2", "&", "REGSTATE_IF_EITHER", ")", "!=", "0", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "something", "accessed", "under", "condition", "COND2", "can", "conflict", "with", "something", "written", "under", "condition", "COND1", "." ]

[ "frv", "0", "0", "0" ]

[]

[ "<s>", "bool", "TeakTargetLowering", "::", "shouldReduceLoadWidth", "(", "SDNode", "*", "Load", ",", "ISD", "::", "LoadExtType", "ExtTy", ",", "EVT", "NewVT", ")", "const", "{", "if", "(", "NewVT", ".", "getSizeInBits", "(", ")", "==", "8", ")", "return", "false", ";", "return", "TargetLowering", "::", "shouldReduceLoadWidth", "(", "Load", ",", "ExtTy", ",", "NewVT", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "believe", "it", "is", "correct", "and", "profitable", "to", "reduce", "the", "load", "node", "to", "a", "smaller", "type", "." ]

[ "Teak", "Teak", "ISD::LoadExtType", "8" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "PPCTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "!", "CallOperandVal", ")", "return", "CW_Default", ";", "Type", "*", "type", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "if", "(", "StringRef", "(", "constraint", ")", "==", "\"wc\"", "&&", "type", "->", "isIntegerTy", "(", "1", ")", ")", "return", "CW_Register", ";", "else", "if", "(", "(", "StringRef", "(", "constraint", ")", "==", "\"wa\"", "||", "StringRef", "(", "constraint", ")", "==", "\"wd\"", "||", "StringRef", "(", "constraint", ")", "==", "\"wf\"", ")", "&&", "type", "->", "isVectorTy", "(", ")", ")", "return", "CW_Register", ";", "else", "if", "(", "StringRef", "(", "constraint", ")", "==", "\"ws\"", "&&", "type", "->", "isDoubleTy", "(", ")", ")", "return", "CW_Register", ";", "else", "if", "(", "StringRef", "(", "constraint", ")", "==", "\"wi\"", "&&", "type", "->", "isIntegerTy", "(", "64", ")", ")", "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", "\"wa\"", "\"wd\"", "\"wf\"", "\"ws\"", "\"wi\"", "64" ]

[]

[ "<s>", "void", "CSKYTargetStreamer", "::", "emitTargetAttributes", "(", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "}", "</s>" ]

[ "Emit", "the", "build", "attributes", "that", "only", "depend", "on", "the", "hardware", "that", "we", "expect", "." ]

[ "CSKY", "CSKY" ]

[]

[ "<s>", "void", "SystemZPassConfig", "::", "addPreSched2", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "&", "IfConverterID", ")", ";", "}", "</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" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Hexagon Common GEP\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon Common GEP\"" ]

[]

[ "<s>", "SDValue", "getAddr", "(", "NodeTy", "*", "N", ",", "SelectionDAG", "&", "DAG", ",", "bool", "IsLocal", "=", "true", ")", "const", "{", "SDLoc", "DL", "(", "N", ")", ";", "EVT", "Ty", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "unsigned", "Flag", "=", "CSKYII", "::", "MO_None", ";", "bool", "IsPIC", "=", "isPositionIndependent", "(", ")", ";", "if", "(", "IsPIC", ")", "Flag", "=", "IsLocal", "?", "CSKYII", "::", "MO_GOTOFF", ":", "IsCall", "?", "CSKYII", "::", "MO_PLT32", ":", "CSKYII", "::", "MO_GOT32", ";", "SDValue", "TCPV", "=", "getTargetConstantPoolValue", "(", "N", ",", "Ty", ",", "DAG", ",", "Flag", ")", ";", "SDValue", "TV", "=", "getTargetNode", "(", "N", ",", "DL", ",", "Ty", ",", "DAG", ",", "Flag", ")", ";", "SDValue", "Addr", "=", "DAG", ".", "getNode", "(", "CSKYISD", "::", "LOAD_ADDR", ",", "DL", ",", "Ty", ",", "{", "TV", ",", "TCPV", "}", ")", ";", "if", "(", "!", "IsPIC", ")", "return", "Addr", ";", "SDValue", "Result", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "Ty", ",", "{", "DAG", ".", "getGLOBAL_OFFSET_TABLE", "(", "Ty", ")", ",", "Addr", "}", ")", ";", "if", "(", "IsLocal", ")", "return", "Result", ";", "return", "DAG", ".", "getLoad", "(", "Ty", ",", "DL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "Result", ",", "MachinePointerInfo", "::", "getGOT", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ")", ";", "}", "</s>" ]

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

[ "CSKY", "CSKYII::MO_None", "CSKYII::MO_GOTOFF", "CSKYII::MO_PLT32", "CSKYII::MO_GOT32", "CSKYISD::LOAD_ADDR", "ISD::ADD" ]

[]

[ "<s>", "static", "reg_class_t", "ix86_preferred_reload_class", "(", "rtx", "x", ",", "reg_class_t", "regclass", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "regclass", "==", "NO_REGS", ")", "return", "NO_REGS", ";", "if", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "regclass", ";", "if", "(", "CONSTANT_P", "(", "x", ")", "&&", "(", "MAYBE_MMX_CLASS_P", "(", "regclass", ")", "||", "MAYBE_SSE_CLASS_P", "(", "regclass", ")", "||", "MAYBE_MASK_CLASS_P", "(", "regclass", ")", ")", ")", "return", "NO_REGS", ";", "if", "(", "TARGET_SSE_MATH", "&&", "!", "TARGET_MIX_SSE_I387", "&&", "SSE_FLOAT_MODE_P", "(", "mode", ")", ")", "return", "SSE_CLASS_P", "(", "regclass", ")", "?", "regclass", ":", "NO_REGS", ";", "if", "(", "CONST_DOUBLE_P", "(", "x", ")", ")", "{", "if", "(", "reg_class_subset_p", "(", "regclass", ",", "GENERAL_REGS", ")", ")", "return", "regclass", ";", "if", "(", "TARGET_80387", "&&", "standard_80387_constant_p", "(", "x", ")", ">", "0", ")", "{", "if", "(", "regclass", "==", "FLOAT_SSE_REGS", ")", "return", "FLOAT_REGS", ";", "if", "(", "regclass", "==", "FP_TOP_SSE_REGS", ")", "return", "FP_TOP_REG", ";", "if", "(", "regclass", "==", "FP_SECOND_SSE_REGS", ")", "return", "FP_SECOND_REG", ";", "if", "(", "regclass", "==", "FLOAT_INT_REGS", "||", "regclass", "==", "FLOAT_REGS", ")", "return", "regclass", ";", "}", "return", "NO_REGS", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "return", "reg_class_subset_p", "(", "regclass", ",", "GENERAL_REGS", ")", "?", "regclass", ":", "NO_REGS", ";", "if", "(", "GET_MODE", "(", "x", ")", "==", "QImode", "&&", "!", "CONSTANT_P", "(", "x", ")", ")", "{", "if", "(", "reg_class_subset_p", "(", "regclass", ",", "Q_REGS", ")", ")", "return", "regclass", ";", "if", "(", "reg_class_subset_p", "(", "Q_REGS", ",", "regclass", ")", ")", "return", "Q_REGS", ";", "return", "NO_REGS", ";", "}", "return", "regclass", ";", "}", "</s>" ]

[ "Put", "float", "CONST_DOUBLE", "in", "the", "constant", "pool", "instead", "of", "fp", "regs", ".", "QImode", "must", "go", "into", "class", "Q_REGS", ".", "Narrow", "ALL_REGS", "to", "GENERAL_REGS", ".", "This", "supports", "allowing", "movsf", "and", "movdf", "to", "do", "mem-to-mem", "moves", "through", "integer", "regs", "." ]

[ "i386", "0" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "Size", "=", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "Align", "=", "FrameInfo", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "Align", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillSaveOpcode", "(", "RC", "->", "getSize", "(", ")", ")", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "SrcReg", ")", "&&", "RC", "->", "getSize", "(", ")", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "}", "MachineInstrBuilder", "Spill", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "ST", ".", "hasScalarStores", "(", ")", ")", "{", "Spill", ".", "addReg", "(", "AMDGPU", "::", "M0", ",", "RegState", "::", "ImplicitDefine", ")", ";", "}", "return", ";", "}", "if", "(", "!", "ST", ".", "isVGPRSpillingEnabled", "(", "*", "MF", "->", "getFunction", "(", ")", ")", ")", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "\"SIInstrInfo::storeRegToStackSlot - Do not know how to\"", "\" spill register\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "KILL", ")", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "assert", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "\"Only VGPR spilling expected\"", ")", ";", "unsigned", "Opcode", "=", "getVGPRSpillSaveOpcode", "(", "RC", "->", "getSize", "(", ")", ")", ";", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "4", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::M0", "\"SIInstrInfo::storeRegToStackSlot - Do not know how to\"", "\" spill register\"", "AMDGPU::KILL", "\"Only VGPR spilling expected\"", "0" ]

[]

[ "<s>", "static", "bool", "mips_rtx_constant_in_small_data_p", "(", "machine_mode", "mode", ")", "{", "return", "(", "!", "TARGET_EMBEDDED_DATA", "&&", "TARGET_LOCAL_SDATA", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "mips_small_data_threshold", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "rtx", "constants", "of", "mode", "MODE", "should", "be", "put", "into", "a", "small", "data", "section", "." ]

[ "mips" ]

[]

[ "<s>", "static", "reg_class_t", "csky_preferred_reload_class", "(", "rtx", "x", ",", "reg_class_t", "rclass", ")", "{", "if", "(", "TARGET_HARD_FLOAT", "&&", "CONST_DOUBLE_P", "(", "x", ")", "&&", "(", "GET_MODE", "(", "x", ")", "==", "DFmode", "||", "GET_MODE", "(", "x", ")", "==", "SFmode", ")", "&&", "rclass", "==", "NO_REGS", ")", "return", "GENERAL_REGS", ";", "return", "rclass", ";", "}", "</s>" ]

[ "Implement", "TARGET_PREFERRED_RELOAD_CLASS", ".", "Given", "an", "rtx", "X", "being", "reloaded", "into", "a", "reg", "required", "to", "be", "in", "class", "CLASS", ",", "return", "the", "class", "of", "reg", "to", "actually", "use", ".", "In", "general", "this", "is", "just", "CLASS", "." ]

[ "csky" ]

[]

[ "<s>", "static", "void", "emit_frame_store_1", "(", "rtx", "value", ",", "rtx", "base_reg", ",", "HOST_WIDE_INT", "frame_bias", ",", "HOST_WIDE_INT", "base_ofs", ",", "rtx", "frame_reg", ")", "{", "rtx", "addr", ",", "mem", ";", "rtx_insn", "*", "insn", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "base_reg", ",", "base_ofs", ")", ";", "mem", "=", "gen_frame_mem", "(", "DImode", ",", "addr", ")", ";", "insn", "=", "emit_move_insn", "(", "mem", ",", "value", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "if", "(", "frame_bias", "||", "value", "!=", "frame_reg", ")", "{", "if", "(", "frame_bias", ")", "{", "addr", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "frame_bias", "+", "base_ofs", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "DImode", ",", "addr", ")", ";", "}", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "mem", ",", "frame_reg", ")", ")", ";", "}", "}", "</s>" ]

[ "Generates", "a", "store", "with", "the", "proper", "unwind", "info", "attached", ".", "VALUE", "is", "stored", "at", "BASE_REG+BASE_OFS", ".", "If", "FRAME_BIAS", "is", "nonzero", ",", "then", "BASE_REG", "contains", "SP+FRAME_BIAS", ",", "and", "that", "is", "the", "unwind", "info", "that", "should", "be", "generated", ".", "If", "FRAME_REG", "!", "=", "VALUE", ",", "then", "VALUE", "is", "being", "stored", "on", "behalf", "of", "FRAME_REG", ",", "and", "FRAME_REG", "should", "be", "present", "in", "the", "unwind", "." ]

[ "alpha", "1" ]

[]

[ "<s>", "static", "rtx", "aarch64_speculation_safe_value", "(", "machine_mode", "mode", ",", "rtx", "result", ",", "rtx", "val", ",", "rtx", "failval", ")", "{", "if", "(", "!", "aarch64_track_speculation", ")", "return", "default_speculation_safe_value", "(", "mode", ",", "result", ",", "val", ",", "failval", ")", ";", "if", "(", "!", "REG_P", "(", "val", ")", ")", "val", "=", "copy_to_mode_reg", "(", "mode", ",", "val", ")", ";", "if", "(", "!", "aarch64_reg_or_zero", "(", "failval", ",", "mode", ")", ")", "failval", "=", "copy_to_mode_reg", "(", "mode", ",", "failval", ")", ";", "emit_insn", "(", "gen_despeculate_copy", "(", "mode", ",", "result", ",", "val", ",", "failval", ")", ")", ";", "return", "result", ";", "}", "</s>" ]

[ "Override", "the", "default", "target", "speculation_safe_value", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isFunctionSafeToOutlineFrom", "(", "MachineFunction", "&", "MF", ",", "bool", "OutlineFromLinkOnceODRs", ")", "const", "{", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "OutlineFromLinkOnceODRs", "&&", "F", ".", "hasLinkOnceODRLinkage", "(", ")", ")", "return", "false", ";", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "if", "(", "!", "AFI", "||", "AFI", "->", "hasRedZone", "(", ")", ".", "getValueOr", "(", "true", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "function", "can", "safely", "be", "outlined", "from", "." ]

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

[]

[ "<s>", "BitVector", "ARMBaseRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "const", "ARMFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "SP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "PC", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "FPSCR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "APSR_NZCV", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", "||", "STI", ".", "isTargetDarwin", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "getFramePointerReg", "(", "STI", ")", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "BasePtr", ")", ";", "for", "(", "size_t", "R", "=", "0", ";", "R", "<", "ARM", "::", "GPRRegClass", ".", "getNumRegs", "(", ")", ";", "++", "R", ")", "{", "if", "(", "STI", ".", "isGPRegisterReserved", "(", "R", ")", ")", "{", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "R0", "+", "R", ")", ";", "}", "}", "if", "(", "!", "STI", ".", "hasD32", "(", ")", ")", "{", "static_assert", "(", "ARM", "::", "D31", "==", "ARM", "::", "D16", "+", "15", ",", "\"Register list not consecutive!\"", ")", ";", "for", "(", "unsigned", "R", "=", "0", ";", "R", "<", "16", ";", "++", "R", ")", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "D16", "+", "R", ")", ";", "}", "const", "TargetRegisterClass", "&", "RC", "=", "ARM", "::", "GPRPairRegClass", ";", "for", "(", "unsigned", "Reg", ":", "RC", ")", "for", "(", "MCSubRegIterator", "SI", "(", "Reg", ",", "this", ")", ";", "SI", ".", "isValid", "(", ")", ";", "++", "SI", ")", "if", "(", "Reserved", ".", "test", "(", "*", "SI", ")", ")", "markSuperRegs", "(", "Reserved", ",", "Reg", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "ZR", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM::SP", "ARM::PC", "ARM::FPSCR", "ARM::APSR_NZCV", "0", "ARM::GPRRegClass", "ARM::R0", "ARM::D31", "ARM::D16", "15", "\"Register list not consecutive!\"", "0", "16", "ARM::D16", "ARM::GPRPairRegClass", "ARM::ZR" ]

[]

[ "<s>", "void", "sparc_expand_prologue", "(", "void", ")", "{", "HOST_WIDE_INT", "size", ";", "rtx_insn", "*", "insn", ";", "sparc_leaf_function_p", "=", "optimize", ">", "0", "&&", "crtl", "->", "is_leaf", "&&", "only_leaf_regs_used", "(", ")", ";", "size", "=", "sparc_compute_frame_size", "(", "get_frame_size", "(", ")", ",", "sparc_leaf_function_p", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "size", ";", "if", "(", "flag_stack_check", "==", "STATIC_BUILTIN_STACK_CHECK", ")", "{", "if", "(", "crtl", "->", "is_leaf", "&&", "!", "cfun", "->", "calls_alloca", ")", "{", "if", "(", "size", ">", "PROBE_INTERVAL", "&&", "size", ">", "STACK_CHECK_PROTECT", ")", "sparc_emit_probe_stack_range", "(", "STACK_CHECK_PROTECT", ",", "size", "-", "STACK_CHECK_PROTECT", ")", ";", "}", "else", "if", "(", "size", ">", "0", ")", "sparc_emit_probe_stack_range", "(", "STACK_CHECK_PROTECT", ",", "size", ")", ";", "}", "if", "(", "size", "==", "0", ")", ";", "else", "if", "(", "sparc_leaf_function_p", ")", "{", "rtx", "size_int_rtx", "=", "GEN_INT", "(", "-", "size", ")", ";", "if", "(", "size", "<=", "4096", ")", "insn", "=", "emit_insn", "(", "gen_stack_pointer_inc", "(", "size_int_rtx", ")", ")", ";", "else", "if", "(", "size", "<=", "8192", ")", "{", "insn", "=", "emit_insn", "(", "gen_stack_pointer_inc", "(", "GEN_INT", "(", "-", "4096", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "emit_insn", "(", "gen_stack_pointer_inc", "(", "GEN_INT", "(", "4096", "-", "size", ")", ")", ")", ";", "}", "else", "{", "rtx", "size_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "emit_move_insn", "(", "size_rtx", ",", "size_int_rtx", ")", ";", "insn", "=", "emit_insn", "(", "gen_stack_pointer_inc", "(", "size_rtx", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_stack_pointer_inc", "(", "size_int_rtx", ")", ")", ";", "}", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "else", "{", "rtx", "size_int_rtx", "=", "GEN_INT", "(", "-", "size", ")", ";", "if", "(", "size", "<=", "4096", ")", "emit_window_save", "(", "size_int_rtx", ")", ";", "else", "if", "(", "size", "<=", "8192", ")", "{", "emit_window_save", "(", "GEN_INT", "(", "-", "4096", ")", ")", ";", "emit_insn", "(", "gen_stack_pointer_inc", "(", "GEN_INT", "(", "4096", "-", "size", ")", ")", ")", ";", "emit_insn", "(", "gen_frame_blockage", "(", ")", ")", ";", "}", "else", "{", "rtx", "size_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "emit_move_insn", "(", "size_rtx", ",", "size_int_rtx", ")", ";", "emit_window_save", "(", "size_rtx", ")", ";", "}", "}", "if", "(", "sparc_leaf_function_p", ")", "{", "sparc_frame_base_reg", "=", "stack_pointer_rtx", ";", "sparc_frame_base_offset", "=", "size", "+", "SPARC_STACK_BIAS", ";", "}", "else", "{", "sparc_frame_base_reg", "=", "hard_frame_pointer_rtx", ";", "sparc_frame_base_offset", "=", "SPARC_STACK_BIAS", ";", "}", "if", "(", "sparc_n_global_fp_regs", ">", "0", ")", "emit_save_or_restore_global_fp_regs", "(", "sparc_frame_base_reg", ",", "sparc_frame_base_offset", "-", "sparc_apparent_frame_size", ",", "SORR_SAVE", ")", ";", "if", "(", "crtl", "->", "uses_pic_offset_table", ")", "load_got_register", "(", ")", ";", "sparc_prologue_data_valid_p", "=", "true", ";", "}", "</s>" ]

[ "Expand", "the", "function", "prologue", ".", "The", "prologue", "is", "responsible", "for", "reserving", "storage", "for", "the", "frame", ",", "saving", "the", "call-saved", "registers", "and", "loading", "the", "PIC", "register", "if", "needed", "." ]

[ "sparc", "0", "0", "0", "4096", "8192", "4096", "1", "4096", "1", "1", "4096", "8192", "4096", "4096", "1", "0" ]

[]

[ "<s>", "void", "KudeyarInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "Opc", ";", "Opc", "=", "Kudeyar", "::", "MOV_RR", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "Kudeyar", "Kudeyar", "Kudeyar::MOV_RR" ]

[]

[ "<s>", "bool", "SIInsertWaits", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changes", "=", "false", ";", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "WaitedOn", "=", "ZeroCounts", ";", "LastIssued", "=", "ZeroCounts", ";", "LastOpcodeType", "=", "OTHER", ";", "LastInstWritesM0", "=", "false", ";", "ReturnsVoid", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "returnsVoid", "(", ")", ";", "memset", "(", "&", "UsedRegs", ",", "0", ",", "sizeof", "(", "UsedRegs", ")", ")", ";", "memset", "(", "&", "DefinedRegs", ",", "0", ",", "sizeof", "(", "DefinedRegs", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_BARRIER", ")", "Changes", "|=", "insertWait", "(", "MBB", ",", "I", ",", "LastIssued", ")", ";", "else", "Changes", "|=", "insertWait", "(", "MBB", ",", "I", ",", "handleOperands", "(", "*", "I", ")", ")", ";", "pushInstruction", "(", "MBB", ",", "I", ")", ";", "handleSendMsg", "(", "MBB", ",", "I", ")", ";", "}", "Changes", "|=", "insertWait", "(", "MBB", ",", "MBB", ".", "getFirstTerminator", "(", ")", ",", "LastIssued", ")", ";", "if", "(", "!", "ReturnsVoid", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", "&&", "I", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_ENDPGM", ")", "I", "->", "eraseFromParent", "(", ")", ";", "}", "}", "return", "Changes", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "0", "0", "AMDGPU::S_BARRIER", "AMDGPU::S_ENDPGM" ]

[]

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

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

[ "OR1K", "OR1K" ]

[]

[ "<s>", "bool", "mips_emit_scc", "(", "enum", "rtx_code", "code", ",", "rtx", "target", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "cmp_operands", "[", "0", "]", ")", ")", "!=", "MODE_INT", ")", "return", "false", ";", "target", "=", "gen_lowpart", "(", "GET_MODE", "(", "cmp_operands", "[", "0", "]", ")", ",", "target", ")", ";", "if", "(", "code", "==", "EQ", "||", "code", "==", "NE", ")", "{", "rtx", "zie", "=", "mips_zero_if_equal", "(", "cmp_operands", "[", "0", "]", ",", "cmp_operands", "[", "1", "]", ")", ";", "mips_emit_binary", "(", "code", ",", "target", ",", "zie", ",", "const0_rtx", ")", ";", "}", "else", "mips_emit_int_relational", "(", "code", ",", "0", ",", "target", ",", "cmp_operands", "[", "0", "]", ",", "cmp_operands", "[", "1", "]", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Try", "comparing", "cmp_operands", "[", "0", "]", "and", "cmp_operands", "[", "1", "]", "using", "rtl", "code", "CODE", ".", "Store", "the", "result", "in", "TARGET", "and", "return", "true", "if", "successful", ".", "On", "64-bit", "targets", ",", "TARGET", "may", "be", "wider", "than", "cmp_operands", "[", "0", "]", "." ]

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

[]

[ "<s>", "void", "X86AsmPrinter", "::", "emitStartOfAsmFile", "(", "Module", "&", "M", ")", "{", "const", "Triple", "&", "TT", "=", "TM", ".", "getTargetTriple", "(", ")", ";", "if", "(", "TT", ".", "isOSBinFormatELF", "(", ")", ")", "{", "unsigned", "FeatureFlagsAnd", "=", "0", ";", "if", "(", "M", ".", "getModuleFlag", "(", "\"cf-protection-branch\"", ")", ")", "FeatureFlagsAnd", "|=", "ELF", "::", "GNU_PROPERTY_X86_FEATURE_1_IBT", ";", "if", "(", "M", ".", "getModuleFlag", "(", "\"cf-protection-return\"", ")", ")", "FeatureFlagsAnd", "|=", "ELF", "::", "GNU_PROPERTY_X86_FEATURE_1_SHSTK", ";", "if", "(", "FeatureFlagsAnd", ")", "{", "if", "(", "!", "TT", ".", "isArch32Bit", "(", ")", "&&", "!", "TT", ".", "isArch64Bit", "(", ")", ")", "llvm_unreachable", "(", "\"CFProtection used on invalid architecture!\"", ")", ";", "MCSection", "*", "Cur", "=", "OutStreamer", "->", "getCurrentSectionOnly", "(", ")", ";", "MCSection", "*", "Nt", "=", "MMI", "->", "getContext", "(", ")", ".", "getELFSection", "(", "\".note.gnu.property\"", ",", "ELF", "::", "SHT_NOTE", ",", "ELF", "::", "SHF_ALLOC", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Nt", ")", ";", "const", "int", "WordSize", "=", "TT", ".", "isArch64Bit", "(", ")", "&&", "TT", ".", "getEnvironment", "(", ")", "!=", "Triple", "::", "GNUX32", "?", "8", ":", "4", ";", "emitAlignment", "(", "WordSize", "==", "4", "?", "Align", "(", "4", ")", ":", "Align", "(", "8", ")", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "4", ",", "4", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "8", "+", "WordSize", ",", "4", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "ELF", "::", "NT_GNU_PROPERTY_TYPE_0", ",", "4", ")", ";", "OutStreamer", "->", "emitBytes", "(", "StringRef", "(", "\"GNU\"", ",", "4", ")", ")", ";", "OutStreamer", "->", "emitInt32", "(", "ELF", "::", "GNU_PROPERTY_X86_FEATURE_1_AND", ")", ";", "OutStreamer", "->", "emitInt32", "(", "4", ")", ";", "OutStreamer", "->", "emitInt32", "(", "FeatureFlagsAnd", ")", ";", "emitAlignment", "(", "WordSize", "==", "4", "?", "Align", "(", "4", ")", ":", "Align", "(", "8", ")", ")", ";", "OutStreamer", "->", "endSection", "(", "Nt", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Cur", ")", ";", "}", "}", "if", "(", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "OutStreamer", "->", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getTextSection", "(", ")", ")", ";", "if", "(", "TT", ".", "isOSBinFormatCOFF", "(", ")", ")", "{", "MCSymbol", "*", "S", "=", "MMI", "->", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "StringRef", "(", "\"@feat.00\"", ")", ")", ";", "OutStreamer", "->", "BeginCOFFSymbolDef", "(", "S", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolStorageClass", "(", "COFF", "::", "IMAGE_SYM_CLASS_STATIC", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolType", "(", "COFF", "::", "IMAGE_SYM_DTYPE_NULL", ")", ";", "OutStreamer", "->", "EndCOFFSymbolDef", "(", ")", ";", "int64_t", "Feat00Flags", "=", "0", ";", "if", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", ")", "{", "Feat00Flags", "|=", "1", ";", "}", "if", "(", "M", ".", "getModuleFlag", "(", "\"cfguard\"", ")", ")", "{", "Feat00Flags", "|=", "0x800", ";", "}", "if", "(", "M", ".", "getModuleFlag", "(", "\"ehcontguard\"", ")", ")", "{", "Feat00Flags", "|=", "0x4000", ";", "}", "OutStreamer", "->", "emitSymbolAttribute", "(", "S", ",", "MCSA_Global", ")", ";", "OutStreamer", "->", "emitAssignment", "(", "S", ",", "MCConstantExpr", "::", "create", "(", "Feat00Flags", ",", "MMI", "->", "getContext", "(", ")", ")", ")", ";", "}", "OutStreamer", "->", "emitSyntaxDirective", "(", ")", ";", "bool", "is16", "=", "TT", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "CODE16", ";", "if", "(", "M", ".", "getModuleInlineAsm", "(", ")", ".", "empty", "(", ")", "&&", "is16", ")", "OutStreamer", "->", "emitAssemblerFlag", "(", "MCAF_Code16", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "\"cf-protection-branch\"", "X86", "\"cf-protection-return\"", "X86", "\"CFProtection used on invalid architecture!\"", "\".note.gnu.property\"", "8", "4", "4", "4", "8", "4", "4", "8", "4", "4", "\"GNU\"", "4", "X86", "4", "4", "4", "8", "\"@feat.00\"", "0", "1", "\"cfguard\"", "0x800", "\"ehcontguard\"", "0x4000" ]

[]

[ "<s>", "bool", "PPCSubtarget", "::", "enablePostRAScheduler", "(", "CodeGenOpt", "::", "Level", "OptLevel", ",", "TargetSubtargetInfo", "::", "AntiDepBreakMode", "&", "Mode", ",", "RegClassVector", "&", "CriticalPathRCs", ")", "const", "{", "Mode", "=", "TargetSubtargetInfo", "::", "ANTIDEP_CRITICAL", ";", "CriticalPathRCs", ".", "clear", "(", ")", ";", "if", "(", "isPPC64", "(", ")", ")", "CriticalPathRCs", ".", "push_back", "(", "&", "PPC", "::", "G8RCRegClass", ")", ";", "else", "CriticalPathRCs", ".", "push_back", "(", "&", "PPC", "::", "GPRCRegClass", ")", ";", "CriticalPathRCs", ".", "push_back", "(", "&", "PPC", "::", "F8RCRegClass", ")", ";", "CriticalPathRCs", ".", "push_back", "(", "&", "PPC", "::", "VRRCRegClass", ")", ";", "return", "OptLevel", ">=", "CodeGenOpt", "::", "Default", ";", "}", "</s>" ]

[ "True", "if", "the", "subtarget", "should", "run", "a", "scheduler", "after", "register", "allocation", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::G8RCRegClass", "PPC::GPRCRegClass", "PPC::F8RCRegClass", "PPC::VRRCRegClass" ]

[]

[ "<s>", "bool", "WinEHStatePass", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "TheModule", "=", "&", "M", ";", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "X86" ]

[]

[ "<s>", "static", "bool", "compute_int_layout", "(", "int", "bitpos", ",", "assign_data_t", "*", "data", ",", "int", "*", "pnregs", ")", "{", "if", "(", "data", "->", "intoffset", "<", "0", ")", "return", "false", ";", "const", "int", "intoffset", "=", "data", "->", "intoffset", ";", "data", "->", "intoffset", "=", "-", "1", ";", "const", "int", "this_slotno", "=", "data", "->", "slotno", "+", "intoffset", "/", "BITS_PER_WORD", ";", "const", "unsigned", "int", "startbit", "=", "ROUND_DOWN", "(", "intoffset", ",", "BITS_PER_WORD", ")", ";", "const", "unsigned", "int", "endbit", "=", "ROUND_UP", "(", "bitpos", ",", "BITS_PER_WORD", ")", ";", "int", "nregs", "=", "(", "endbit", "-", "startbit", ")", "/", "BITS_PER_WORD", ";", "if", "(", "nregs", ">", "0", "&&", "nregs", ">", "SPARC_INT_ARG_MAX", "-", "this_slotno", ")", "{", "nregs", "=", "SPARC_INT_ARG_MAX", "-", "this_slotno", ";", "data", "->", "stack", "=", "1", ";", "}", "if", "(", "nregs", "<=", "0", ")", "return", "false", ";", "*", "pnregs", "=", "nregs", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "function_arg_record_value", ".", "Compute", "the", "number", "of", "integer", "registers", "to", "be", "assigned", "between", "PARMS-", ">", "intoffset", "and", "BITPOS", ".", "Return", "true", "if", "at", "least", "one", "integer", "register", "is", "assigned", "or", "false", "otherwise", "." ]

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

[]

[ "<s>", "BitVector", "SparcRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "SparcSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G1", ")", ";", "if", "(", "ReserveAppRegisters", ")", "{", "Reserved", ".", "set", "(", "SP", "::", "G2", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G3", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G4", ")", ";", "}", "if", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", ")", "Reserved", ".", "set", "(", "SP", "::", "G5", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "O6", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "I6", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "I7", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G0", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G6", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G7", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G0_G1", ")", ";", "if", "(", "ReserveAppRegisters", ")", "Reserved", ".", "set", "(", "SP", "::", "G2_G3", ")", ";", "if", "(", "ReserveAppRegisters", "||", "!", "Subtarget", ".", "is64Bit", "(", ")", ")", "Reserved", ".", "set", "(", "SP", "::", "G4_G5", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "O6_O7", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "I6_I7", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G6_G7", ")", ";", "if", "(", "!", "Subtarget", ".", "isV9", "(", ")", ")", "{", "for", "(", "unsigned", "n", "=", "0", ";", "n", "!=", "16", ";", "++", "n", ")", "{", "for", "(", "MCRegAliasIterator", "AI", "(", "SP", "::", "D16", "+", "n", ",", "this", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Reserved", ".", "set", "(", "*", "AI", ")", ";", "}", "}", "for", "(", "unsigned", "n", "=", "0", ";", "n", "<", "31", ";", "n", "++", ")", "Reserved", ".", "set", "(", "SP", "::", "ASR1", "+", "n", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "Sparc", "SP::G1", "SP::G2", "SP::G3", "SP::G4", "SP::G5", "SP::O6", "SP::I6", "SP::I7", "SP::G0", "SP::G6", "SP::G7", "SP::G0_G1", "SP::G2_G3", "SP::G4_G5", "SP::O6_O7", "SP::I6_I7", "SP::G6_G7", "0", "16", "SP::D16", "0", "31", "SP::ASR1" ]

[]

[ "<s>", "static", "int", "arm_cortex_m_branch_cost", "(", "bool", "speed_p", ",", "bool", "predictable_p", ")", "{", "return", "(", "TARGET_32BIT", "&&", "speed_p", ")", "?", "1", ":", "arm_default_branch_cost", "(", "speed_p", ",", "predictable_p", ")", ";", "}", "</s>" ]

[ "Thumb-2", "branches", "are", "relatively", "cheap", "on", "Cortex-M", "processors", "(", "``", "1", "+", "P", "cycles", "''", "on", "Cortex-M4", ",", "where", "P", "varies", "from", "1", "to", "3", "according", "to", "some", "criteria", ")", ",", "since", "sequences", "of", "non-executed", "instructions", "in", "IT", "blocks", "probably", "take", "the", "same", "amount", "of", "time", "as", "executed", "instructions", "(", "and", "the", "IT", "instruction", "itself", "takes", "space", "in", "icache", ")", ".", "This", "function", "was", "experimentally", "determined", "to", "give", "good", "results", "on", "a", "popular", "embedded", "benchmark", "." ]

[ "arm", "1" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "KnownBits", "&", "Known", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "BitWidth", "=", "Known", ".", "getBitWidth", "(", ")", ";", "Known", ".", "resetAll", "(", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARMISD", "::", "ADDC", ":", "case", "ARMISD", "::", "ADDE", ":", "case", "ARMISD", "::", "SUBC", ":", "case", "ARMISD", "::", "SUBE", ":", "if", "(", "Op", ".", "getResNo", "(", ")", "==", "0", ")", "{", "SDValue", "LHS", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "SDValue", "RHS", "=", "Op", ".", "getOperand", "(", "1", ")", ";", "if", "(", "Op", "->", "getOpcode", "(", ")", "==", "ARMISD", "::", "ADDE", "&&", "isNullConstant", "(", "LHS", ")", "&&", "isNullConstant", "(", "RHS", ")", ")", "{", "Known", ".", "Zero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "1", ")", ";", "return", ";", "}", "}", "break", ";", "case", "ARMISD", "::", "CMOV", ":", "{", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "Known", ",", "Depth", "+", "1", ")", ";", "if", "(", "Known", ".", "isUnknown", "(", ")", ")", "return", ";", "KnownBits", "KnownRHS", ";", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "KnownRHS", ",", "Depth", "+", "1", ")", ";", "Known", ".", "Zero", "&=", "KnownRHS", ".", "Zero", ";", "Known", ".", "One", "&=", "KnownRHS", ".", "One", ";", "return", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "ConstantSDNode", "*", "CN", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "1", ")", ")", ";", "Intrinsic", "::", "ID", "IntID", "=", "static_cast", "<", "Intrinsic", "::", "ID", ">", "(", "CN", "->", "getZExtValue", "(", ")", ")", ";", "switch", "(", "IntID", ")", "{", "default", ":", "return", ";", "case", "Intrinsic", "::", "arm_ldaex", ":", "case", "Intrinsic", "::", "arm_ldrex", ":", "{", "EVT", "VT", "=", "cast", "<", "MemIntrinsicSDNode", ">", "(", "Op", ")", "->", "getMemoryVT", "(", ")", ";", "unsigned", "MemBits", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "Known", ".", "Zero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "MemBits", ")", ";", "return", ";", "}", "}", "}", "case", "ARMISD", "::", "BFI", ":", "{", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "Known", ",", "Depth", "+", "1", ")", ";", "ConstantSDNode", "*", "CI", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "const", "APInt", "&", "Mask", "=", "CI", "->", "getAPIntValue", "(", ")", ";", "Known", ".", "Zero", "&=", "Mask", ";", "Known", ".", "One", "&=", "Mask", ";", "return", ";", "}", "}", "}", "</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", "." ]

[ "ARM", "ARM", "ARMISD::ADDC", "ARMISD::ADDE", "ARMISD::SUBC", "ARMISD::SUBE", "0", "0", "1", "ARMISD::ADDE", "1", "ARMISD::CMOV", "0", "1", "1", "1", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::ID", "Intrinsic::ID", "Intrinsic::arm_ldaex", "Intrinsic::arm_ldrex", "ARMISD::BFI", "0", "1", "2" ]

[]

[ "<s>", "static", "int", "s390_adjust_priority", "(", "rtx_insn", "*", "insn", ",", "int", "priority", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "return", "priority", ";", "if", "(", "s390_tune", "!=", "PROCESSOR_2084_Z990", "&&", "s390_tune", "!=", "PROCESSOR_2094_Z9_109", "&&", "s390_tune", "!=", "PROCESSOR_2097_Z10", "&&", "s390_tune", "!=", "PROCESSOR_2817_Z196", "&&", "s390_tune", "!=", "PROCESSOR_2827_ZEC12", ")", "return", "priority", ";", "switch", "(", "s390_safe_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_FSTOREDF", ":", "case", "TYPE_FSTORESF", ":", "priority", "=", "priority", "<<", "3", ";", "break", ";", "case", "TYPE_STORE", ":", "case", "TYPE_STM", ":", "priority", "=", "priority", "<<", "1", ";", "break", ";", "default", ":", "break", ";", "}", "return", "priority", ";", "}", "</s>" ]

[ "A", "C", "statement", "(", "sans", "semicolon", ")", "to", "update", "the", "integer", "scheduling", "priority", "INSN_PRIORITY", "(", "INSN", ")", ".", "Reduce", "the", "priority", "to", "execute", "the", "INSN", "earlier", ",", "increase", "the", "priority", "to", "execute", "INSN", "later", ".", "Do", "not", "define", "this", "macro", "if", "you", "do", "not", "need", "to", "adjust", "the", "scheduling", "priorities", "of", "insns", ".", "A", "LA", "instruction", "maybe", "scheduled", "later", ",", "since", "the", "pipeline", "bypasses", "the", "calculated", "value", "." ]

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

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isFMAFasterThanFMulAndFAdd", "(", "const", "Function", "&", "F", ",", "Type", "*", "Ty", ")", "const", "{", "switch", "(", "Ty", "->", "getScalarType", "(", ")", "->", "getTypeID", "(", ")", ")", "{", "case", "Type", "::", "FloatTyID", ":", "case", "Type", "::", "DoubleTyID", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "an", "FMA", "operation", "is", "faster", "than", "a", "pair", "of", "fmul", "and", "fadd", "instructions", "." ]

[ "AArch64", "AArch64" ]

[]

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

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

[ "WebAssembly", "WebAssembly", "\"********** Memory Intrinsic Results **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "\"MemIntrinsicResults expects liveness tracking\"", "\"Basic Block: \"", "WebAssembly::CALL_i32", "WebAssembly::CALL_i64" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isShuffleMaskLegal", "(", "ArrayRef", "<", "int", ">", ",", "EVT", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "isFPExtFree", "(", "EVT", "DestVT", ",", "EVT", "SrcVT", ")", "const", "{", "assert", "(", "DestVT", ".", "isFloatingPoint", "(", ")", "&&", "SrcVT", ".", "isFloatingPoint", "(", ")", "&&", "\"invalid fpext types\"", ")", ";", "if", "(", "DestVT", "==", "MVT", "::", "f128", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "fpext", "operation", "is", "free", "(", "for", "instance", ",", "because", "single-precision", "floating-point", "numbers", "are", "implicitly", "extended", "to", "double-precision", ")", "." ]

[ "PowerPC", "PPC", "\"invalid fpext types\"", "MVT::f128" ]

[]

[ "<s>", "static", "reg_class_t", "m32c_preferred_output_reload_class", "(", "rtx", "x", ",", "reg_class_t", "rclass", ")", "{", "return", "m32c_preferred_reload_class", "(", "x", ",", "rclass", ")", ";", "}", "</s>" ]

[ "Implements", "PREFERRED_OUTPUT_RELOAD_CLASS", "." ]

[ "m32c" ]

[]

[ "<s>", "BitVector", "X86RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "for", "(", "MCSubRegIterator", "I", "(", "X86", "::", "RSP", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "for", "(", "MCSubRegIterator", "I", "(", "X86", "::", "RIP", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "for", "(", "MCSubRegIterator", "I", "(", "X86", "::", "RBP", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "{", "CallingConv", "::", "ID", "CC", "=", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ";", "const", "uint32_t", "*", "RegMask", "=", "getCallPreservedMask", "(", "CC", ")", ";", "if", "(", "MachineOperand", "::", "clobbersPhysReg", "(", "RegMask", ",", "getBaseRegister", "(", ")", ")", ")", "report_fatal_error", "(", "\"Stack realignment in presence of dynamic allocas is not supported with\"", "\"this calling convention.\"", ")", ";", "for", "(", "MCSubRegIterator", "I", "(", "getBaseRegister", "(", ")", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "Reserved", ".", "set", "(", "X86", "::", "CS", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "SS", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "DS", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "ES", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "FS", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "GS", ")", ";", "for", "(", "unsigned", "n", "=", "0", ";", "n", "!=", "8", ";", "++", "n", ")", "Reserved", ".", "set", "(", "X86", "::", "ST0", "+", "n", ")", ";", "if", "(", "!", "Is64Bit", ")", "{", "Reserved", ".", "set", "(", "X86", "::", "SIL", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "DIL", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "BPL", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "SPL", ")", ";", "for", "(", "unsigned", "n", "=", "0", ";", "n", "!=", "8", ";", "++", "n", ")", "{", "for", "(", "MCRegAliasIterator", "AI", "(", "X86", "::", "R8", "+", "n", ",", "this", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Reserved", ".", "set", "(", "*", "AI", ")", ";", "for", "(", "MCRegAliasIterator", "AI", "(", "X86", "::", "XMM8", "+", "n", ",", "this", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Reserved", ".", "set", "(", "*", "AI", ")", ";", "}", "}", "if", "(", "!", "Is64Bit", "||", "!", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX512", "(", ")", ")", "{", "for", "(", "unsigned", "n", "=", "16", ";", "n", "!=", "32", ";", "++", "n", ")", "{", "for", "(", "MCRegAliasIterator", "AI", "(", "X86", "::", "XMM0", "+", "n", ",", "this", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Reserved", ".", "set", "(", "*", "AI", ")", ";", "}", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::RSP", "X86::RIP", "X86::RBP", "\"Stack realignment in presence of dynamic allocas is not supported with\"", "\"this calling convention.\"", "X86::CS", "X86::SS", "X86::DS", "X86::ES", "X86::FS", "X86::GS", "0", "8", "X86::ST0", "X86::SIL", "X86::DIL", "X86::BPL", "X86::SPL", "0", "8", "X86::R8", "X86::XMM8", "X86", "16", "32", "X86::XMM0" ]

[]

[ "<s>", "void", "ix86_split_fp_branch", "(", "enum", "rtx_code", "code", ",", "rtx", "op1", ",", "rtx", "op2", ",", "rtx", "target1", ",", "rtx", "target2", ",", "rtx", "tmp", ")", "{", "rtx", "condition", ";", "rtx", "i", ";", "if", "(", "target2", "!=", "pc_rtx", ")", "{", "std", "::", "swap", "(", "target1", ",", "target2", ")", ";", "code", "=", "reverse_condition_maybe_unordered", "(", "code", ")", ";", "}", "condition", "=", "ix86_expand_fp_compare", "(", "code", ",", "op1", ",", "op2", ",", "tmp", ")", ";", "i", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "condition", ",", "target1", ",", "target2", ")", ")", ")", ";", "if", "(", "split_branch_probability", ">=", "0", ")", "add_int_reg_note", "(", "i", ",", "REG_BR_PROB", ",", "split_branch_probability", ")", ";", "}", "</s>" ]

[ "Split", "branch", "based", "on", "floating", "point", "condition", "." ]

[ "i386", "0" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "!", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "{", "initialize", "(", "MF", ")", ";", "}", "return", "removeLD", "(", ")", ";", "}", "</s>" ]

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

[ "BPF" ]

[]

[ "<s>", "static", "bool", "expand_vec_perm_pshufb2", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "rtx", "rperm", "[", "2", "]", "[", "16", "]", ",", "vperm", ",", "l", ",", "h", ",", "op", ",", "m128", ";", "unsigned", "int", "i", ",", "nelt", ",", "eltsz", ";", "if", "(", "!", "TARGET_SSSE3", "||", "GET_MODE_SIZE", "(", "d", "->", "vmode", ")", "!=", "16", ")", "return", "false", ";", "gcc_assert", "(", "!", "d", "->", "one_operand_p", ")", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "nelt", "=", "d", "->", "nelt", ";", "eltsz", "=", "GET_MODE_SIZE", "(", "GET_MODE_INNER", "(", "d", "->", "vmode", ")", ")", ";", "m128", "=", "GEN_INT", "(", "-", "128", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "unsigned", "j", ",", "e", "=", "d", "->", "perm", "[", "i", "]", ";", "unsigned", "which", "=", "(", "e", ">=", "nelt", ")", ";", "if", "(", "e", ">=", "nelt", ")", "e", "-=", "nelt", ";", "for", "(", "j", "=", "0", ";", "j", "<", "eltsz", ";", "++", "j", ")", "{", "rperm", "[", "which", "]", "[", "i", "*", "eltsz", "+", "j", "]", "=", "GEN_INT", "(", "e", "*", "eltsz", "+", "j", ")", ";", "rperm", "[", "1", "-", "which", "]", "[", "i", "*", "eltsz", "+", "j", "]", "=", "m128", ";", "}", "}", "vperm", "=", "gen_rtx_CONST_VECTOR", "(", "V16QImode", ",", "gen_rtvec_v", "(", "16", ",", "rperm", "[", "0", "]", ")", ")", ";", "vperm", "=", "force_reg", "(", "V16QImode", ",", "vperm", ")", ";", "l", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "op", "=", "gen_lowpart", "(", "V16QImode", ",", "d", "->", "op0", ")", ";", "emit_insn", "(", "gen_ssse3_pshufbv16qi3", "(", "l", ",", "op", ",", "vperm", ")", ")", ";", "vperm", "=", "gen_rtx_CONST_VECTOR", "(", "V16QImode", ",", "gen_rtvec_v", "(", "16", ",", "rperm", "[", "1", "]", ")", ")", ";", "vperm", "=", "force_reg", "(", "V16QImode", ",", "vperm", ")", ";", "h", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "op", "=", "gen_lowpart", "(", "V16QImode", ",", "d", "->", "op1", ")", ";", "emit_insn", "(", "gen_ssse3_pshufbv16qi3", "(", "h", ",", "op", ",", "vperm", ")", ")", ";", "op", "=", "d", "->", "target", ";", "if", "(", "d", "->", "vmode", "!=", "V16QImode", ")", "op", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "emit_insn", "(", "gen_iorv16qi3", "(", "op", ",", "l", ",", "h", ")", ")", ";", "if", "(", "op", "!=", "d", "->", "target", ")", "emit_move_insn", "(", "d", "->", "target", ",", "gen_lowpart", "(", "d", "->", "vmode", ",", "op", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "expand_vec_perm_even_odd_1", ".", "Implement", "the", "double-word", "permutation", "with", "two", "pshufb", "insns", "and", "an", "ior", ".", "We", "should", "have", "already", "failed", "all", "two", "instruction", "sequences", "." ]

[ "i386", "2", "16", "16", "128", "0", "0", "1", "16", "0", "16", "1" ]

[]

[ "<s>", "void", "HexagonInstPrinter", "::", "printInst", "(", "const", "HexagonMCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "const", "char", "packetPadding", "[", "]", "=", "\" \"", ";", "const", "char", "startPacket", "=", "'{'", ",", "endPacket", "=", "'}'", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "ENDLOOP0", ")", "{", "assert", "(", "MI", "->", "isEndPacket", "(", ")", "&&", "\"Loop end must also end the packet\"", ")", ";", "if", "(", "MI", "->", "isStartPacket", "(", ")", ")", "{", "HexagonMCInst", "Nop", ";", "StringRef", "NoAnnot", ";", "Nop", ".", "setOpcode", "(", "Hexagon", "::", "NOP", ")", ";", "Nop", ".", "setStartPacket", "(", "MI", "->", "isStartPacket", "(", ")", ")", ";", "printInst", "(", "&", "Nop", ",", "O", ",", "NoAnnot", ")", ";", "}", "if", "(", "MI", "->", "isEndPacket", "(", ")", ")", "O", "<<", "packetPadding", "<<", "endPacket", ";", "printInstruction", "(", "MI", ",", "O", ")", ";", "}", "else", "{", "if", "(", "MI", "->", "isStartPacket", "(", ")", ")", "O", "<<", "packetPadding", "<<", "startPacket", "<<", "'\\n'", ";", "printInstruction", "(", "MI", ",", "O", ")", ";", "if", "(", "MI", "->", "isEndPacket", "(", ")", ")", "O", "<<", "'\\n'", "<<", "packetPadding", "<<", "endPacket", ";", "}", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "\" \"", "Hexagon::ENDLOOP0", "\"Loop end must also end the packet\"", "Hexagon", "Hexagon::NOP" ]

[]

[ "<s>", "bool", "ARM64FastISel", "::", "isTypeLegal", "(", "Type", "*", "Ty", ",", "MVT", "&", "VT", ")", "{", "EVT", "evt", "=", "TLI", ".", "getValueType", "(", "Ty", ",", "true", ")", ";", "if", "(", "evt", "==", "MVT", "::", "Other", "||", "!", "evt", ".", "isSimple", "(", ")", ")", "return", "false", ";", "VT", "=", "evt", ".", "getSimpleVT", "(", ")", ";", "return", "TLI", ".", "isTypeLegal", "(", "VT", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "type", "is", "legal", "." ]

[ "ARM64", "ARM64", "MVT::Other" ]

[]

[ "<s>", "static", "void", "cygwin_d_register_target_info", "(", "void", ")", "{", "const", "struct", "d_target_info_spec", "handlers", "[", "]", "=", "{", "{", "\"objectFormat\"", ",", "cygwin_d_handle_target_object_format", "}", ",", "{", "NULL", ",", "NULL", "}", ",", "}", ";", "d_add_target_info_handlers", "(", "handlers", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_D_REGISTER_OS_TARGET_INFO", "for", "Cygwin", "targets", "." ]

[ "i386", "\"objectFormat\"" ]

[]

[ "<s>", "static", "int", "push_data_area", "(", "v850_data_area", "data_area", ")", "{", "data_area_stack_element", "*", "elem", ";", "elem", "=", "(", "data_area_stack_element", "*", ")", "xmalloc", "(", "sizeof", "(", "*", "elem", ")", ")", ";", "if", "(", "elem", "==", "NULL", ")", "return", "0", ";", "elem", "->", "prev", "=", "data_area_stack", ";", "elem", "->", "data_area", "=", "data_area", ";", "data_area_stack", "=", "elem", ";", "return", "1", ";", "}", "</s>" ]

[ "Push", "a", "data", "area", "onto", "the", "stack", "." ]

[ "v850", "0", "1" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "&", "MI", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown rematerializable operation!\"", ")", ";", "break", ";", "case", "PPC", "::", "LI", ":", "case", "PPC", "::", "LI8", ":", "case", "PPC", "::", "PLI", ":", "case", "PPC", "::", "PLI8", ":", "case", "PPC", "::", "LIS", ":", "case", "PPC", "::", "LIS8", ":", "case", "PPC", "::", "ADDIStocHA", ":", "case", "PPC", "::", "ADDIStocHA8", ":", "case", "PPC", "::", "ADDItocL", ":", "case", "PPC", "::", "LOAD_STACK_GUARD", ":", "case", "PPC", "::", "XXLXORz", ":", "case", "PPC", "::", "XXLXORspz", ":", "case", "PPC", "::", "XXLXORdpz", ":", "case", "PPC", "::", "XXLEQVOnes", ":", "case", "PPC", "::", "XXSPLTI32DX", ":", "case", "PPC", "::", "XXSPLTIW", ":", "case", "PPC", "::", "XXSPLTIDP", ":", "case", "PPC", "::", "V_SET0B", ":", "case", "PPC", "::", "V_SET0H", ":", "case", "PPC", "::", "V_SET0", ":", "case", "PPC", "::", "V_SETALLONESB", ":", "case", "PPC", "::", "V_SETALLONESH", ":", "case", "PPC", "::", "V_SETALLONES", ":", "case", "PPC", "::", "CRSET", ":", "case", "PPC", "::", "CRUNSET", ":", "case", "PPC", "::", "XXSETACCZ", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"Unknown rematerializable operation!\"", "PPC::LI", "PPC::LI8", "PPC::PLI", "PPC::PLI8", "PPC::LIS", "PPC::LIS8", "PPC::ADDIStocHA", "PPC::ADDIStocHA8", "PPC::ADDItocL", "PPC::LOAD_STACK_GUARD", "PPC::XXLXORz", "PPC::XXLXORspz", "PPC::XXLXORdpz", "PPC::XXLEQVOnes", "PPC::XXSPLTI32DX", "PPC::XXSPLTIW", "PPC::XXSPLTIDP", "PPC::V_SET0B", "PPC::V_SET0H", "PPC::V_SET0", "PPC::V_SETALLONESB", "PPC::V_SETALLONESH", "PPC::V_SETALLONES", "PPC::CRSET", "PPC::CRUNSET", "PPC::XXSETACCZ" ]

[]

[ "<s>", "AArch64Subtarget", "::", "AArch64Subtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ",", "bool", "LittleEndian", ")", ":", "AArch64GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ReserveXRegister", "(", "AArch64", "::", "GPR64commonRegClass", ".", "getNumRegs", "(", ")", ")", ",", "CustomCallSavedXRegs", "(", "AArch64", "::", "GPR64commonRegClass", ".", "getNumRegs", "(", ")", ")", ",", "IsLittle", "(", "LittleEndian", ")", ",", "TargetTriple", "(", "TT", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "FS", ",", "CPU", ")", ")", ",", "TSInfo", "(", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "if", "(", "AArch64", "::", "isX18ReservedByDefault", "(", "TT", ")", ")", "ReserveXRegister", ".", "set", "(", "18", ")", ";", "CallLoweringInfo", ".", "reset", "(", "new", "AArch64CallLowering", "(", "*", "getTargetLowering", "(", ")", ")", ")", ";", "InlineAsmLoweringInfo", ".", "reset", "(", "new", "InlineAsmLowering", "(", "getTargetLowering", "(", ")", ")", ")", ";", "Legalizer", ".", "reset", "(", "new", "AArch64LegalizerInfo", "(", "*", "this", ")", ")", ";", "auto", "*", "RBI", "=", "new", "AArch64RegisterBankInfo", "(", "*", "getRegisterInfo", "(", ")", ")", ";", "InstSelector", ".", "reset", "(", "createAArch64InstructionSelector", "(", "*", "static_cast", "<", "const", "AArch64TargetMachine", "*", ">", "(", "&", "TM", ")", ",", "*", "this", ",", "*", "RBI", ")", ")", ";", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64::GPR64commonRegClass", "AArch64::GPR64commonRegClass", "AArch64::isX18ReservedByDefault", "18", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "void", "MipsMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "MCInst", "TmpInst", "=", "MI", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Mips", "::", "DSLL", ":", "case", "Mips", "::", "DSRL", ":", "case", "Mips", "::", "DSRA", ":", "case", "Mips", "::", "DROTR", ":", "case", "Mips", "::", "DSLL_MM64R6", ":", "case", "Mips", "::", "DSRL_MM64R6", ":", "case", "Mips", "::", "DSRA_MM64R6", ":", "case", "Mips", "::", "DROTR_MM64R6", ":", "LowerLargeShift", "(", "TmpInst", ")", ";", "break", ";", "case", "Mips", "::", "BEQC", ":", "case", "Mips", "::", "BNEC", ":", "case", "Mips", "::", "BEQC64", ":", "case", "Mips", "::", "BNEC64", ":", "case", "Mips", "::", "BOVC", ":", "case", "Mips", "::", "BOVC_MMR6", ":", "case", "Mips", "::", "BNVC", ":", "case", "Mips", "::", "BNVC_MMR6", ":", "LowerCompactBranch", "(", "TmpInst", ")", ";", "}", "unsigned", "long", "N", "=", "Fixups", ".", "size", "(", ")", ";", "uint32_t", "Binary", "=", "getBinaryCodeForInstr", "(", "TmpInst", ",", "Fixups", ",", "STI", ")", ";", "unsigned", "Opcode", "=", "TmpInst", ".", "getOpcode", "(", ")", ";", "if", "(", "(", "Opcode", "!=", "Mips", "::", "NOP", ")", "&&", "(", "Opcode", "!=", "Mips", "::", "SLL", ")", "&&", "(", "Opcode", "!=", "Mips", "::", "SLL_MM", ")", "&&", "!", "Binary", ")", "llvm_unreachable", "(", "\"unimplemented opcode in encodeInstruction()\"", ")", ";", "int", "NewOpcode", "=", "-", "1", ";", "if", "(", "isMicroMips", "(", "STI", ")", ")", "{", "if", "(", "isMips32r6", "(", "STI", ")", ")", "{", "NewOpcode", "=", "Mips", "::", "MipsR62MicroMipsR6", "(", "Opcode", ",", "Mips", "::", "Arch_micromipsr6", ")", ";", "if", "(", "NewOpcode", "==", "-", "1", ")", "NewOpcode", "=", "Mips", "::", "Std2MicroMipsR6", "(", "Opcode", ",", "Mips", "::", "Arch_micromipsr6", ")", ";", "}", "else", "NewOpcode", "=", "Mips", "::", "Std2MicroMips", "(", "Opcode", ",", "Mips", "::", "Arch_micromips", ")", ";", "if", "(", "NewOpcode", "==", "-", "1", ")", "NewOpcode", "=", "Mips", "::", "Dsp2MicroMips", "(", "Opcode", ",", "Mips", "::", "Arch_mmdsp", ")", ";", "if", "(", "NewOpcode", "!=", "-", "1", ")", "{", "if", "(", "Fixups", ".", "size", "(", ")", ">", "N", ")", "Fixups", ".", "pop_back", "(", ")", ";", "Opcode", "=", "NewOpcode", ";", "TmpInst", ".", "setOpcode", "(", "NewOpcode", ")", ";", "Binary", "=", "getBinaryCodeForInstr", "(", "TmpInst", ",", "Fixups", ",", "STI", ")", ";", "}", "}", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "TmpInst", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "if", "(", "!", "Size", ")", "llvm_unreachable", "(", "\"Desc.getSize() returns 0\"", ")", ";", "EmitInstruction", "(", "Binary", ",", "Size", ",", "STI", ",", "OS", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::DSLL", "Mips::DSRL", "Mips::DSRA", "Mips::DROTR", "Mips::DSLL_MM64R6", "Mips::DSRL_MM64R6", "Mips::DSRA_MM64R6", "Mips::DROTR_MM64R6", "Mips::BEQC", "Mips::BNEC", "Mips::BEQC64", "Mips::BNEC64", "Mips::BOVC", "Mips::BOVC_MMR6", "Mips::BNVC", "Mips::BNVC_MMR6", "Mips::NOP", "Mips::SLL", "Mips::SLL_MM", "\"unimplemented opcode in encodeInstruction()\"", "1", "Mips", "Mips", "Mips::MipsR62MicroMipsR6", "Mips::Arch_micromipsr6", "1", "Mips::Std2MicroMipsR6", "Mips::Arch_micromipsr6", "Mips::Std2MicroMips", "Mips::Arch_micromips", "1", "Mips::Dsp2MicroMips", "Mips::Arch_mmdsp", "1", "\"Desc.getSize() returns 0\"" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "const", "Type", "*", "Ty", ")", "const", "{", "EVT", "VT", "=", "getValueType", "(", "Ty", ",", "true", ")", ";", "if", "(", "!", "isLegalAddressImmediate", "(", "AM", ".", "BaseOffs", ",", "VT", ",", "Subtarget", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "false", ";", "default", ":", "if", "(", "AM", ".", "BaseOffs", ")", "return", "false", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "if", "(", "Subtarget", "->", "isThumb2", "(", ")", ")", "return", "isLegalT2ScaledAddressingMode", "(", "AM", ",", "VT", ")", ";", "int", "Scale", "=", "AM", ".", "Scale", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "return", "false", ";", "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i32", ":", "if", "(", "Scale", "<", "0", ")", "Scale", "=", "-", "Scale", ";", "if", "(", "Scale", "==", "1", ")", "return", "true", ";", "return", "isPowerOf2_32", "(", "Scale", "&", "~", "1", ")", ";", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i64", ":", "if", "(", "(", "(", "unsigned", ")", "AM", ".", "HasBaseReg", "+", "Scale", ")", "<=", "2", ")", "return", "true", ";", "return", "false", ";", "case", "MVT", "::", "isVoid", ":", "if", "(", "Scale", "&", "1", ")", "return", "false", ";", "return", "isPowerOf2_32", "(", "Scale", ")", ";", "}", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "1", "MVT::i1", "MVT::i8", "MVT::i32", "0", "1", "1", "MVT::i16", "MVT::i64", "2", "MVT::isVoid", "1" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "isBranchOffsetInRange", "(", "unsigned", "BranchOp", ",", "int64_t", "BrOffset", ")", "const", "{", "unsigned", "XLen", "=", "STI", ".", "getXLen", "(", ")", ";", "switch", "(", "BranchOp", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected opcode!\"", ")", ";", "case", "RISCV", "::", "BEQ", ":", "case", "RISCV", "::", "BNE", ":", "case", "RISCV", "::", "BLT", ":", "case", "RISCV", "::", "BGE", ":", "case", "RISCV", "::", "BLTU", ":", "case", "RISCV", "::", "BGEU", ":", "case", "RISCV", "::", "P_BEQIMM", ":", "case", "RISCV", "::", "P_BNEIMM", ":", "return", "isIntN", "(", "13", ",", "BrOffset", ")", ";", "case", "RISCV", "::", "JAL", ":", "case", "RISCV", "::", "PseudoBR", ":", "return", "isIntN", "(", "21", ",", "BrOffset", ")", ";", "case", "RISCV", "::", "PseudoJump", ":", "return", "isIntN", "(", "32", ",", "SignExtend64", "(", "BrOffset", "+", "0x800", ",", "XLen", ")", ")", ";", "}", "}", "</s>" ]

[ "Determine", "if", "the", "branch", "target", "is", "in", "range", "." ]

[ "RI5CY", "RISCV", "\"Unexpected opcode!\"", "RISCV::BEQ", "RISCV::BNE", "RISCV::BLT", "RISCV::BGE", "RISCV::BLTU", "RISCV::BGEU", "RISCV::P_BEQIMM", "RISCV::P_BNEIMM", "13", "RISCV::JAL", "RISCV::PseudoBR", "21", "RISCV::PseudoJump", "32", "0x800" ]

[]

[ "<s>", "void", "SparcFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "if", "(", "!", "DisableLeafProc", "&&", "isLeafProc", "(", "MF", ")", ")", "{", "SparcMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setLeafProc", "(", "true", ")", ";", "remapRegsForLeafProc", "(", "MF", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

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

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "SIMachineFunctionInfo", "*", "Info", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "Info", "->", "isEntryFunction", "(", ")", ")", "return", "false", ";", "return", "TargetRegisterInfo", "::", "canRealignStack", "(", "MF", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "stack", "can", "be", "realigned", "for", "the", "target", "." ]

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

[]

[ "<s>", "const", "char", "*", "output_reload_insisf", "(", "rtx", "*", "op", ",", "rtx", "clobber_reg", ",", "int", "*", "len", ")", "{", "if", "(", "AVR_HAVE_MOVW", "&&", "!", "test_hard_reg_class", "(", "LD_REGS", ",", "op", "[", "0", "]", ")", "&&", "(", "CONST_INT_P", "(", "op", "[", "1", "]", ")", "||", "CONST_FIXED_P", "(", "op", "[", "1", "]", ")", "||", "CONST_DOUBLE_P", "(", "op", "[", "1", "]", ")", ")", ")", "{", "int", "len_clr", ",", "len_noclr", ";", "output_reload_in_const", "(", "op", ",", "clobber_reg", ",", "&", "len_clr", ",", "true", ")", ";", "output_reload_in_const", "(", "op", ",", "clobber_reg", ",", "&", "len_noclr", ",", "false", ")", ";", "if", "(", "len_noclr", "-", "len_clr", "==", "4", ")", "{", "avr_asm_len", "(", "\"mov %A0,__zero_reg__\"", "CR_TAB", "\"mov %B0,__zero_reg__\"", "CR_TAB", "\"movw %C0,%A0\"", ",", "&", "op", "[", "0", "]", ",", "len", ",", "3", ")", ";", "output_reload_in_const", "(", "op", ",", "clobber_reg", ",", "len", ",", "true", ")", ";", "if", "(", "len", ")", "*", "len", "+=", "3", ";", "return", "\"\"", ";", "}", "}", "output_reload_in_const", "(", "op", ",", "clobber_reg", ",", "len", ",", "false", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Reload", "a", "SI", "or", "SF", "compile", "time", "constant", "OP", "[", "1", "]", "into", "the", "register", "OP", "[", "0", "]", ".", "CLOBBER_REG", "is", "a", "QI", "clobber", "reg", "needed", "to", "move", "vast", "majority", "of", "consts", "into", "a", "NO_LD_REGS", "register", ".", "If", "CLOBBER_REG", "is", "NULL_RTX", "we", "either", "do", "n't", "need", "a", "clobber", "reg", "or", "have", "to", "cook", "one", "up", ".", "LEN", "==", "NULL", ":", "Output", "instructions", ".", "LEN", "!", "=", "NULL", ":", "Output", "nothing", ".", "Set", "*", "LEN", "to", "number", "of", "words", "occupied", "by", "the", "insns", "printed", ".", "Return", "``", "''", "." ]

[ "avr", "0", "1", "1", "1", "4", "\"mov %A0,__zero_reg__\"", "\"mov %B0,__zero_reg__\"", "\"movw %C0,%A0\"", "0", "3", "3", "\"\"", "\"\"" ]

[]

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

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "void", "NyuziAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", "->", "getIterator", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "do", "{", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "while", "(", "(", "++", "I", "!=", "E", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi" ]

[]

[ "<s>", "SDNode", "*", "HexagonDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "return", "NULL", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "Constant", ":", "return", "SelectConstant", "(", "N", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "SelectAdd", "(", "N", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "SelectSHL", "(", "N", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "SelectLoad", "(", "N", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "SelectStore", "(", "N", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "SelectSelect", "(", "N", ")", ";", "case", "ISD", "::", "TRUNCATE", ":", "return", "SelectTruncate", "(", "N", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "SelectMul", "(", "N", ")", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "SelectZeroExtend", "(", "N", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "SelectIntrinsicWOChain", "(", "N", ")", ";", "}", "return", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "ISD::Constant", "ISD::ADD", "ISD::SHL", "ISD::LOAD", "ISD::STORE", "ISD::SELECT", "ISD::TRUNCATE", "ISD::MUL", "ISD::ZERO_EXTEND", "ISD::INTRINSIC_WO_CHAIN" ]

[]

[ "<s>", "virtual", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "PostDominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "PostDominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "FunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "emitEndOfAsmFile", "(", "Module", "&", "M", ")", "{", "for", "(", "std", "::", "map", "<", "const", "char", "*", ",", "const", "Mips16HardFloatInfo", "::", "FuncSignature", "*", ">", "::", "const_iterator", "it", "=", "StubsNeeded", ".", "begin", "(", ")", ";", "it", "!=", "StubsNeeded", ".", "end", "(", ")", ";", "++", "it", ")", "{", "const", "char", "*", "Symbol", "=", "it", "->", "first", ";", "const", "Mips16HardFloatInfo", "::", "FuncSignature", "*", "Signature", "=", "it", "->", "second", ";", "EmitFPCallStub", "(", "Symbol", ",", "Signature", ")", ";", "}", "OutStreamer", "->", "SwitchSection", "(", "OutContext", ".", "getObjectFileInfo", "(", ")", "->", "getTextSection", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "getMCOpcodeFromPseudo", "(", "Opc", ")", ";", "unsigned", "DescSize", "=", "Desc", ".", "getSize", "(", ")", ";", "if", "(", "DescSize", "==", "8", "||", "DescSize", "==", "4", ")", "return", "DescSize", ";", "assert", "(", "DescSize", "==", "0", ")", ";", "if", "(", "isVALU", "(", "MI", ")", "||", "isSALU", "(", "MI", ")", ")", "{", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "if", "(", "Src0Idx", "==", "-", "1", ")", "return", "4", ";", "if", "(", "isLiteralConstantLike", "(", "MI", ".", "getOperand", "(", "Src0Idx", ")", ",", "getOpSize", "(", "MI", ",", "Src0Idx", ")", ")", ")", "return", "8", ";", "int", "Src1Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "if", "(", "Src1Idx", "==", "-", "1", ")", "return", "4", ";", "if", "(", "isLiteralConstantLike", "(", "MI", ".", "getOperand", "(", "Src1Idx", ")", ",", "getOpSize", "(", "MI", ",", "Src1Idx", ")", ")", ")", "return", "8", ";", "return", "4", ";", "}", "switch", "(", "Opc", ")", "{", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "case", "TargetOpcode", "::", "BUNDLE", ":", "case", "TargetOpcode", "::", "EH_LABEL", ":", "return", "0", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "{", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "char", "*", "AsmStr", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ";", "return", "getInlineAsmLength", "(", "AsmStr", ",", "*", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "default", ":", "llvm_unreachable", "(", "\"unable to find instruction size\"", ")", ";", "}", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "AMDGPU", "SI", "8", "4", "0", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "4", "8", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "4", "8", "4", "0", "0", "\"unable to find instruction size\"" ]

[]

[ "<s>", "int", "neon_struct_mem_operand", "(", "rtx", "op", ")", "{", "rtx", "ind", ";", "if", "(", "!", "(", "reload_in_progress", "||", "reload_completed", ")", "&&", "(", "reg_mentioned_p", "(", "frame_pointer_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "arg_pointer_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_incoming_args_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_outgoing_args_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_stack_dynamic_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_stack_vars_rtx", ",", "op", ")", ")", ")", "return", "FALSE", ";", "if", "(", "!", "MEM_P", "(", "op", ")", ")", "return", "FALSE", ";", "ind", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "reload_completed", "&&", "(", "LABEL_REF_P", "(", "ind", ")", "||", "(", "GET_CODE", "(", "ind", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "ind", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "0", ")", ")", "==", "LABEL_REF", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "1", ")", ")", ")", ")", ")", "return", "TRUE", ";", "if", "(", "REG_P", "(", "ind", ")", ")", "return", "arm_address_register_rtx_p", "(", "ind", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "ind", ")", "==", "POST_INC", "||", "GET_CODE", "(", "ind", ")", "==", "PRE_DEC", ")", "return", "arm_address_register_rtx_p", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "0", ")", ";", "return", "FALSE", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "OP", "is", "a", "mem", "suitable", "for", "loading/storing", "a", "Neon", "struct", "type", "." ]

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

[]

[ "<s>", "unsigned", "int", "compute_a_shift_length", "(", "rtx", "operands", "[", "3", "]", ",", "rtx_code", "code", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "enum", "shift_type", "shift_type", ";", "enum", "shift_mode", "shift_mode", ";", "struct", "shift_info", "info", ";", "unsigned", "int", "wlength", "=", "0", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "shift_mode", "=", "QIshift", ";", "break", ";", "case", "E_HImode", ":", "shift_mode", "=", "HIshift", ";", "break", ";", "case", "E_SImode", ":", "shift_mode", "=", "SIshift", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "ASHIFTRT", ":", "shift_type", "=", "SHIFT_ASHIFTRT", ";", "break", ";", "case", "LSHIFTRT", ":", "shift_type", "=", "SHIFT_LSHIFTRT", ";", "break", ";", "case", "ASHIFT", ":", "shift_type", "=", "SHIFT_ASHIFT", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "!=", "CONST_INT", ")", "{", "get_shift_alg", "(", "shift_type", ",", "shift_mode", ",", "1", ",", "&", "info", ")", ";", "return", "(", "4", "+", "h8300_asm_insn_count", "(", "info", ".", "shift1", ")", ")", "*", "2", ";", "}", "else", "{", "int", "n", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "n", "<", "0", ")", "n", "=", "0", ";", "else", "if", "(", "(", "unsigned", "int", ")", "n", ">", "GET_MODE_BITSIZE", "(", "mode", ")", ")", "n", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "get_shift_alg", "(", "shift_type", ",", "shift_mode", ",", "n", ",", "&", "info", ")", ";", "switch", "(", "info", ".", "alg", ")", "{", "case", "SHIFT_SPECIAL", ":", "wlength", "+=", "h8300_asm_insn_count", "(", "info", ".", "special", ")", ";", "if", "(", "strstr", "(", "info", ".", "special", ",", "\"xor.l\"", ")", "!=", "NULL", ")", "wlength", "++", ";", "case", "SHIFT_INLINE", ":", "n", "=", "info", ".", "remainder", ";", "if", "(", "info", ".", "shift2", "!=", "NULL", ")", "{", "wlength", "+=", "h8300_asm_insn_count", "(", "info", ".", "shift2", ")", "*", "(", "n", "/", "2", ")", ";", "n", "=", "n", "%", "2", ";", "}", "wlength", "+=", "h8300_asm_insn_count", "(", "info", ".", "shift1", ")", "*", "n", ";", "return", "2", "*", "wlength", ";", "case", "SHIFT_ROT_AND", ":", "{", "int", "m", "=", "GET_MODE_BITSIZE", "(", "mode", ")", "-", "n", ";", "gcc_assert", "(", "info", ".", "shift1", ")", ";", "if", "(", "info", ".", "shift2", "!=", "NULL", ")", "{", "wlength", "+=", "h8300_asm_insn_count", "(", "info", ".", "shift2", ")", "*", "(", "m", "/", "2", ")", ";", "m", "=", "m", "%", "2", ";", "}", "wlength", "+=", "h8300_asm_insn_count", "(", "info", ".", "shift1", ")", "*", "m", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "wlength", "+=", "1", ";", "break", ";", "case", "E_HImode", ":", "wlength", "+=", "2", ";", "break", ";", "case", "E_SImode", ":", "wlength", "+=", "3", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "2", "*", "wlength", ";", "}", "case", "SHIFT_LOOP", ":", "if", "(", "info", ".", "shift2", "!=", "NULL", ")", "{", "wlength", "+=", "3", "+", "h8300_asm_insn_count", "(", "info", ".", "shift2", ")", ";", "if", "(", "n", "%", "2", ")", "wlength", "+=", "h8300_asm_insn_count", "(", "info", ".", "shift1", ")", ";", "}", "else", "{", "wlength", "+=", "3", "+", "h8300_asm_insn_count", "(", "info", ".", "shift1", ")", ";", "}", "return", "2", "*", "wlength", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "Compute", "the", "length", "of", "a", "shift", "insn", "." ]

[ "h8300", "3", "0", "0", "2", "1", "4", "2", "2", "0", "0", "\"xor.l\"", "2", "2", "2", "2", "2", "1", "2", "3", "2", "3", "2", "3", "2" ]

[]