Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "bool", "classof", "(", "const", "MCExpr", "*", "E", ")", "{", "return", "E", "->", "getKind", "(", ")", "==", "MCExpr", "::", "Target", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "ARM" ]

[]

[ "<s>", "static", "rtx", "cr16_function_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "cum", "->", "last_parm_in_reg", "=", "0", ";", "if", "(", "arg", ".", "end_marker_p", "(", ")", ")", "return", "NULL_RTX", ";", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "arg", ")", "||", "(", "cum", "->", "ints", "<", "0", ")", ")", "return", "NULL_RTX", ";", "if", "(", "arg", ".", "mode", "==", "BLKmode", ")", "{", "if", "(", "enough_regs_for_param", "(", "cum", ",", "arg", ".", "type", ",", "arg", ".", "mode", ")", "!=", "0", ")", "{", "cum", "->", "last_parm_in_reg", "=", "1", ";", "return", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "MIN_REG_FOR_PASSING_ARGS", "+", "cum", "->", "ints", ")", ";", "}", "}", "if", "(", "(", "MIN_REG_FOR_PASSING_ARGS", "+", "cum", "->", "ints", ")", ">", "MAX_REG_FOR_PASSING_ARGS", ")", "return", "NULL_RTX", ";", "else", "{", "if", "(", "enough_regs_for_param", "(", "cum", ",", "arg", ".", "type", ",", "arg", ".", "mode", ")", "!=", "0", ")", "{", "cum", "->", "last_parm_in_reg", "=", "1", ";", "return", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "MIN_REG_FOR_PASSING_ARGS", "+", "cum", "->", "ints", ")", ";", "}", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Implements", "the", "macro", "FUNCTION_ARG", "defined", "in", "cr16.h", "." ]

[ "cr16", "0", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "SDValue", "AArch64SelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "Align", "Alignment", ",", "bool", "isVolatile", ",", "bool", "AlwaysInline", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "const", "AArch64Subtarget", "&", "STI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "if", "(", "STI", ".", "hasMOPS", "(", ")", ")", "return", "EmitMOPS", "(", "AArch64ISD", "::", "MOPS_MEMCOPY", ",", "DAG", ",", "DL", ",", "Chain", ",", "Dst", ",", "Src", ",", "Size", ",", "Alignment", ",", "isVolatile", ",", "DstPtrInfo", ",", "SrcPtrInfo", ")", ";", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memcpy", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64ISD::MOPS_MEMCOPY" ]

[]

[ "<s>", "void", "SparcRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", "+", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "Offset", ">=", "-", "4096", "&&", "Offset", "<=", "4095", ")", "{", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "SP", "::", "I6", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "{", "unsigned", "OffHi", "=", "(", "unsigned", ")", "Offset", ">>", "10U", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "SETHIi", ")", ",", "SP", "::", "G1", ")", ".", "addImm", "(", "OffHi", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "ADDrr", ")", ",", "SP", "::", "G1", ")", ".", "addReg", "(", "SP", "::", "G1", ")", ".", "addReg", "(", "SP", "::", "I6", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "SP", "::", "G1", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", "&", "(", "(", "1", "<<", "10", ")", "-", "1", ")", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP", "SP", "0", "\"Unexpected\"", "1", "4096", "4095", "SP::I6", "1", "10U", "SP::SETHIi", "SP::G1", "SP::ADDrr", "SP::G1", "SP::G1", "SP::I6", "SP::G1", "1", "1", "10", "1" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AddrSpace", ",", "unsigned", "Align", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "Subtarget", "->", "requiresStrictAlign", "(", ")", ")", "return", "false", ";", "if", "(", "Fast", ")", "{", "*", "Fast", "=", "!", "Subtarget", "->", "isMisaligned128StoreSlow", "(", ")", "||", "VT", ".", "getStoreSize", "(", ")", "!=", "16", "||", "Align", "<=", "2", "||", "VT", "==", "MVT", "::", "v2i64", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "16", "2", "MVT::v2i64" ]

[]

[ "<s>", "bool", "PPCDarwinAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "static", "const", "char", "*", "const", "CPUDirectives", "[", "]", "=", "{", "\"\"", ",", "\"ppc\"", ",", "\"ppc601\"", ",", "\"ppc602\"", ",", "\"ppc603\"", ",", "\"ppc7400\"", ",", "\"ppc750\"", ",", "\"ppc970\"", ",", "\"ppc64\"", "}", ";", "unsigned", "Directive", "=", "Subtarget", ".", "getDarwinDirective", "(", ")", ";", "if", "(", "Subtarget", ".", "isGigaProcessor", "(", ")", "&&", "Directive", "<", "PPC", "::", "DIR_970", ")", "Directive", "=", "PPC", "::", "DIR_970", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", "&&", "Directive", "<", "PPC", "::", "DIR_7400", ")", "Directive", "=", "PPC", "::", "DIR_7400", ";", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", "&&", "Directive", "<", "PPC", "::", "DIR_970", ")", "Directive", "=", "PPC", "::", "DIR_64", ";", "assert", "(", "Directive", "<=", "PPC", "::", "DIR_64", "&&", "\"Directive out of range.\"", ")", ";", "O", "<<", "\"\\t.machine \"", "<<", "CPUDirectives", "[", "Directive", "]", "<<", "'\\n'", ";", "bool", "Result", "=", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "MMI", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ";", "assert", "(", "MMI", ")", ";", "DW", "=", "getAnalysisIfAvailable", "<", "DwarfWriter", ">", "(", ")", ";", "assert", "(", "DW", "&&", "\"DwarfWriter is not available\"", ")", ";", "DW", "->", "BeginModule", "(", "&", "M", ",", "MMI", ",", "O", ",", "this", ",", "TAI", ")", ";", "Mang", "->", "setUseQuotes", "(", "true", ")", ";", "SwitchToTextSection", "(", "\"\\t.section __TEXT,__textcoal_nt,coalesced,\"", "\"pure_instructions\"", ")", ";", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "{", "SwitchToTextSection", "(", "\"\\t.section __TEXT,__picsymbolstub1,symbol_stubs,\"", "\"pure_instructions,32\"", ")", ";", "}", "else", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", "{", "SwitchToTextSection", "(", "\"\\t.section __TEXT,__symbol_stub1,symbol_stubs,\"", "\"pure_instructions,16\"", ")", ";", "}", "SwitchToSection", "(", "TAI", "->", "getTextSection", "(", ")", ")", ";", "return", "Result", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"\"", "\"ppc\"", "\"ppc601\"", "\"ppc602\"", "\"ppc603\"", "\"ppc7400\"", "\"ppc750\"", "\"ppc970\"", "\"ppc64\"", "PPC::DIR_970", "PPC::DIR_970", "PPC::DIR_7400", "PPC::DIR_7400", "PPC", "PPC::DIR_970", "PPC::DIR_64", "PPC::DIR_64", "\"Directive out of range.\"", "\"\\t.machine \"", "\"DwarfWriter is not available\"", "\"\\t.section __TEXT,__textcoal_nt,coalesced,\"", "\"pure_instructions\"", "\"\\t.section __TEXT,__picsymbolstub1,symbol_stubs,\"", "\"pure_instructions,32\"", "\"\\t.section __TEXT,__symbol_stub1,symbol_stubs,\"", "\"pure_instructions,16\"" ]

[]

[ "<s>", "static", "int", "rs6000_register_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "int", "ret", ";", "if", "(", "TARGET_DEBUG_COST", ")", "dbg_cost_ctrl", "++", ";", "if", "(", "reg_classes_intersect_p", "(", "to", ",", "GENERAL_REGS", ")", "||", "reg_classes_intersect_p", "(", "from", ",", "GENERAL_REGS", ")", ")", "{", "reg_class_t", "rclass", "=", "from", ";", "if", "(", "!", "reg_classes_intersect_p", "(", "to", ",", "GENERAL_REGS", ")", ")", "rclass", "=", "to", ";", "if", "(", "rclass", "==", "FLOAT_REGS", "||", "rclass", "==", "ALTIVEC_REGS", "||", "rclass", "==", "VSX_REGS", ")", "ret", "=", "(", "rs6000_memory_move_cost", "(", "mode", ",", "rclass", ",", "false", ")", "+", "rs6000_memory_move_cost", "(", "mode", ",", "GENERAL_REGS", ",", "false", ")", ")", ";", "else", "if", "(", "rclass", "==", "CR_REGS", ")", "ret", "=", "4", ";", "else", "if", "(", "(", "rs6000_cpu", "==", "PROCESSOR_POWER6", "||", "rs6000_cpu", "==", "PROCESSOR_POWER7", "||", "rs6000_cpu", "==", "PROCESSOR_POWER8", "||", "rs6000_cpu", "==", "PROCESSOR_POWER9", ")", "&&", "reg_classes_intersect_p", "(", "rclass", ",", "LINK_OR_CTR_REGS", ")", ")", "ret", "=", "6", "*", "hard_regno_nregs", "[", "0", "]", "[", "mode", "]", ";", "else", "ret", "=", "2", "*", "hard_regno_nregs", "[", "0", "]", "[", "mode", "]", ";", "}", "else", "if", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "reg_classes_intersect_p", "(", "to", ",", "VSX_REGS", ")", "&&", "reg_classes_intersect_p", "(", "from", ",", "VSX_REGS", ")", ")", "ret", "=", "2", "*", "hard_regno_nregs", "[", "FIRST_FPR_REGNO", "]", "[", "mode", "]", ";", "else", "if", "(", "reg_classes_intersect_p", "(", "to", ",", "from", ")", ")", "ret", "=", "(", "FLOAT128_2REG_P", "(", "mode", ")", ")", "?", "4", ":", "2", ";", "else", "ret", "=", "(", "rs6000_register_move_cost", "(", "mode", ",", "GENERAL_REGS", ",", "to", ")", "+", "rs6000_register_move_cost", "(", "mode", ",", "from", ",", "GENERAL_REGS", ")", ")", ";", "if", "(", "TARGET_DEBUG_COST", ")", "{", "if", "(", "dbg_cost_ctrl", "==", "1", ")", "fprintf", "(", "stderr", ",", "\"rs6000_register_move_cost:, ret=%d, mode=%s, from=%s, to=%s\\n\"", ",", "ret", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "reg_class_names", "[", "from", "]", ",", "reg_class_names", "[", "to", "]", ")", ";", "dbg_cost_ctrl", "--", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "A", "C", "expression", "returning", "the", "cost", "of", "moving", "data", "from", "a", "register", "of", "class", "CLASS1", "to", "one", "of", "CLASS2", "." ]

[ "rs6000", "4", "6", "0", "2", "0", "2", "4", "2", "1", "\"rs6000_register_move_cost:, ret=%d, mode=%s, from=%s, to=%s\\n\"" ]

[]

[ "<s>", "static", "bool", "aarch64_evpc_rev", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "j", ",", "diff", ",", "nelt", "=", "d", "->", "nelt", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ")", ";", "if", "(", "!", "d", "->", "one_vector_p", ")", "return", "false", ";", "diff", "=", "d", "->", "perm", "[", "0", "]", ";", "switch", "(", "diff", ")", "{", "case", "7", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_aarch64_rev64v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_aarch64_rev64v8qi", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "case", "3", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_aarch64_rev32v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_aarch64_rev32v8qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_aarch64_rev64v8hi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_aarch64_rev64v4hi", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "case", "1", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_aarch64_rev16v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_aarch64_rev16v8qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_aarch64_rev32v8hi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_aarch64_rev32v4hi", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_aarch64_rev64v4si", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_aarch64_rev64v2si", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_aarch64_rev64v4sf", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_aarch64_rev64v2sf", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "default", ":", "return", "false", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "+=", "diff", "+", "1", ")", "for", "(", "j", "=", "0", ";", "j", "<=", "diff", ";", "j", "+=", "1", ")", "{", "gcc_assert", "(", "i", "+", "j", "<", "nelt", ")", ";", "if", "(", "d", "->", "perm", "[", "i", "+", "j", "]", "!=", "i", "+", "diff", "-", "j", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "emit_insn", "(", "gen", "(", "d", "->", "target", ",", "d", "->", "op0", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "the", "REV", "insns", "." ]

[ "aarch64", "0", "7", "3", "1", "0", "1", "0", "1" ]

[]

[ "<s>", "void", "Nios2RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "}", "</s>" ]

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

[ "Nios2", "Nios2" ]

[]

[ "<s>", "void", "HexagonAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MCInst", "MCB", ";", "MCB", ".", "setOpcode", "(", "Hexagon", "::", "BUNDLE", ")", ";", "MCB", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "const", "MCInstrInfo", "&", "MCII", "=", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "MII", "=", "MI", "->", "getIterator", "(", ")", ";", "for", "(", "++", "MII", ";", "MII", "!=", "MBB", "->", "instr_end", "(", ")", "&&", "MII", "->", "isInsideBundle", "(", ")", ";", "++", "MII", ")", "if", "(", "!", "MII", "->", "isDebugValue", "(", ")", "&&", "!", "MII", "->", "isImplicitDef", "(", ")", ")", "HexagonLowerToMC", "(", "MCII", ",", "&", "*", "MII", ",", "MCB", ",", "*", "this", ")", ";", "}", "else", "HexagonLowerToMC", "(", "MCII", ",", "MI", ",", "MCB", ",", "*", "this", ")", ";", "bool", "Ok", "=", "HexagonMCInstrInfo", "::", "canonicalizePacket", "(", "MCII", ",", "*", "Subtarget", ",", "OutStreamer", "->", "getContext", "(", ")", ",", "MCB", ",", "nullptr", ")", ";", "assert", "(", "Ok", ")", ";", "(", "void", ")", "Ok", ";", "if", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "MCB", ")", "==", "0", ")", "return", ";", "OutStreamer", "->", "EmitInstruction", "(", "MCB", ",", "getSubtargetInfo", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::BUNDLE", "0", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "0" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 LEA Fixup\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 LEA Fixup\"" ]

[]

[ "<s>", "static", "bool", "h8300_print_operand_punct_valid_p", "(", "unsigned", "char", "code", ")", "{", "return", "(", "code", "==", "'#'", ")", ";", "}", "</s>" ]

[ "Implements", "TARGET_PRINT_OPERAND_PUNCT_VALID_P", "." ]

[ "h8300" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "SystemZTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "CallOperandVal", "==", "NULL", ")", "return", "CW_Default", ";", "Type", "*", "type", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "switch", "(", "*", "constraint", ")", "{", "default", ":", "weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "info", ",", "constraint", ")", ";", "break", ";", "case", "'a'", ":", "case", "'d'", ":", "case", "'h'", ":", "case", "'r'", ":", "if", "(", "CallOperandVal", "->", "getType", "(", ")", "->", "isIntegerTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'f'", ":", "if", "(", "type", "->", "isFloatingPointTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'I'", ":", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "if", "(", "isUInt", "<", "8", ">", "(", "C", "->", "getZExtValue", "(", ")", ")", ")", "weight", "=", "CW_Constant", ";", "break", ";", "case", "'J'", ":", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "if", "(", "isUInt", "<", "12", ">", "(", "C", "->", "getZExtValue", "(", ")", ")", ")", "weight", "=", "CW_Constant", ";", "break", ";", "case", "'K'", ":", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "if", "(", "isInt", "<", "16", ">", "(", "C", "->", "getSExtValue", "(", ")", ")", ")", "weight", "=", "CW_Constant", ";", "break", ";", "case", "'L'", ":", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "if", "(", "isInt", "<", "20", ">", "(", "C", "->", "getSExtValue", "(", ")", ")", ")", "weight", "=", "CW_Constant", ";", "break", ";", "case", "'M'", ":", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "if", "(", "C", "->", "getZExtValue", "(", ")", "==", "0x7fffffff", ")", "weight", "=", "CW_Constant", ";", "break", ";", "}", "return", "weight", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "8", "12", "16", "20", "0x7fffffff" ]

[]

[ "<s>", "static", "void", "mips_output_args_xfer", "(", "int", "fp_code", ",", "char", "direction", ")", "{", "unsigned", "int", "gparg", ",", "fparg", ",", "f", ";", "CUMULATIVE_ARGS", "cum", ";", "gcc_assert", "(", "TARGET_OLDABI", ")", ";", "mips_init_cumulative_args", "(", "&", "cum", ",", "NULL", ")", ";", "for", "(", "f", "=", "(", "unsigned", "int", ")", "fp_code", ";", "f", "!=", "0", ";", "f", ">>=", "2", ")", "{", "machine_mode", "mode", ";", "struct", "mips_arg_info", "info", ";", "if", "(", "(", "f", "&", "3", ")", "==", "1", ")", "mode", "=", "SFmode", ";", "else", "if", "(", "(", "f", "&", "3", ")", "==", "2", ")", "mode", "=", "DFmode", ";", "else", "gcc_unreachable", "(", ")", ";", "mips_get_arg_info", "(", "&", "info", ",", "&", "cum", ",", "mode", ",", "NULL", ",", "true", ")", ";", "gparg", "=", "mips_arg_regno", "(", "&", "info", ",", "false", ")", ";", "fparg", "=", "mips_arg_regno", "(", "&", "info", ",", "true", ")", ";", "if", "(", "mode", "==", "SFmode", ")", "mips_output_32bit_xfer", "(", "direction", ",", "gparg", ",", "fparg", ")", ";", "else", "mips_output_64bit_xfer", "(", "direction", ",", "gparg", ",", "fparg", ")", ";", "mips_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "cum", ")", ",", "mode", ",", "NULL", ",", "true", ")", ";", "}", "}", "</s>" ]

[ "Write", "out", "code", "to", "move", "floating-point", "arguments", "into", "or", "out", "of", "general", "registers", ".", "FP_CODE", "is", "the", "code", "describing", "which", "arguments", "are", "present", "(", "see", "the", "comment", "above", "the", "definition", "of", "CUMULATIVE_ARGS", "in", "mips.h", ")", ".", "DIRECTION", "is", "as", "for", "mips_output_32bit_xfer", "." ]

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

[]

[ "<s>", "bool", "Cpu0AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "int", "Offset", "=", "0", ";", "if", "(", "ExtraCode", ")", "{", "return", "true", ";", "}", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"unexpected inline asm memory operand\"", ")", ";", "O", "<<", "Offset", "<<", "\"($\"", "<<", "Cpu0InstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "\")\"", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "Cpu0", "Cpu0", "0", "\"unexpected inline asm memory operand\"", "\"($\"", "Cpu0", "\")\"" ]

[]

[ "<s>", "void", "OR1KMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "unsigned", "CurByte", "=", "0", ";", "++", "MCNumEmitted", ";", "unsigned", "Value", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "EmitBEConstant", "(", "Value", ",", "4", ",", "CurByte", ",", "OS", ")", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K", "0", "4" ]

[]

[ "<s>", "outliner", "::", "OutlinedFunction", "RISCVInstrInfo", "::", "getOutliningCandidateInfo", "(", "std", "::", "vector", "<", "outliner", "::", "Candidate", ">", "&", "RepeatedSequenceLocs", ")", "const", "{", "auto", "CannotInsertCall", "=", "[", "]", "(", "outliner", "::", "Candidate", "&", "C", ")", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "C", ".", "getMF", "(", ")", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "C", ".", "initLRU", "(", "*", "TRI", ")", ";", "LiveRegUnits", "LRU", "=", "C", ".", "LRU", ";", "return", "!", "LRU", ".", "available", "(", "RISCV", "::", "X5", ")", ";", "}", ";", "llvm", "::", "erase_if", "(", "RepeatedSequenceLocs", ",", "CannotInsertCall", ")", ";", "if", "(", "RepeatedSequenceLocs", ".", "size", "(", ")", "<", "2", ")", "return", "outliner", "::", "OutlinedFunction", "(", ")", ";", "unsigned", "SequenceSize", "=", "0", ";", "auto", "I", "=", "RepeatedSequenceLocs", "[", "0", "]", ".", "front", "(", ")", ";", "auto", "E", "=", "std", "::", "next", "(", "RepeatedSequenceLocs", "[", "0", "]", ".", "back", "(", ")", ")", ";", "for", "(", ";", "I", "!=", "E", ";", "++", "I", ")", "SequenceSize", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "unsigned", "CallOverhead", "=", "8", ";", "for", "(", "auto", "&", "C", ":", "RepeatedSequenceLocs", ")", "C", ".", "setCallInfo", "(", "MachineOutlinerDefault", ",", "CallOverhead", ")", ";", "unsigned", "FrameOverhead", "=", "4", ";", "if", "(", "RepeatedSequenceLocs", "[", "0", "]", ".", "getMF", "(", ")", "->", "getSubtarget", "(", ")", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureStdExtC", "]", ")", "FrameOverhead", "=", "2", ";", "return", "outliner", "::", "OutlinedFunction", "(", "RepeatedSequenceLocs", ",", "SequenceSize", ",", "FrameOverhead", ",", "MachineOutlinerDefault", ")", ";", "}", "</s>" ]

[ "Returns", "a", "outliner", ":", ":OutlinedFunction", "struct", "containing", "target-specific", "information", "for", "a", "set", "of", "outlining", "candidates", "." ]

[ "RISCV", "RISCV", "RISCV::X5", "2", "0", "0", "0", "8", "4", "0", "RISCV::FeatureStdExtC", "2" ]

[]

[ "<s>", "static", "rtx", "mips_return_fpr_pair", "(", "enum", "machine_mode", "mode", ",", "enum", "machine_mode", "mode1", ",", "HOST_WIDE_INT", "offset1", ",", "enum", "machine_mode", "mode2", ",", "HOST_WIDE_INT", "offset2", ")", "{", "int", "inc", ";", "inc", "=", "(", "TARGET_NEWABI", "?", "2", ":", "FP_INC", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode1", ",", "FP_RETURN", ")", ",", "GEN_INT", "(", "offset1", ")", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode2", ",", "FP_RETURN", "+", "inc", ")", ",", "GEN_INT", "(", "offset2", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "a", "composite", "value", "in", "a", "pair", "of", "floating-point", "registers", ".", "MODE1", "and", "OFFSET1", "are", "the", "mode", "and", "byte", "offset", "for", "the", "first", "value", ",", "likewise", "MODE2", "and", "OFFSET2", "for", "the", "second", ".", "MODE", "is", "the", "mode", "of", "the", "complete", "value", ".", "For", "n32", "&", "n64", ",", "$", "f0", "always", "holds", "the", "first", "value", "and", "$", "f2", "the", "second", ".", "Otherwise", "the", "values", "are", "packed", "together", "as", "closely", "as", "possible", "." ]

[ "mips", "2", "2" ]

[]

[ "<s>", "static", "tree", "resolve_vec_addec_subec", "(", "resolution", "*", "res", ",", "rs6000_gen_builtins", "fcode", ",", "tree", "*", "args", ",", "tree", "*", "types", ",", "location_t", "loc", ")", "{", "if", "(", "TREE_CODE", "(", "types", "[", "0", "]", ")", "!=", "VECTOR_TYPE", "||", "!", "lang_hooks", ".", "types_compatible_p", "(", "types", "[", "0", "]", ",", "types", "[", "1", "]", ")", "||", "!", "lang_hooks", ".", "types_compatible_p", "(", "types", "[", "1", "]", ",", "types", "[", "2", "]", ")", ")", "{", "*", "res", "=", "resolved_bad", ";", "return", "error_mark_node", ";", "}", "switch", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "types", "[", "0", "]", ")", ")", ")", "{", "case", "E_SImode", ":", "{", "args", "[", "0", "]", "=", "save_expr", "(", "args", "[", "0", "]", ")", ";", "args", "[", "1", "]", "=", "save_expr", "(", "args", "[", "1", "]", ")", ";", "vec", "<", "tree", ",", "va_gc", ">", "*", "params", "=", "make_tree_vector", "(", ")", ";", "vec_safe_push", "(", "params", ",", "args", "[", "0", "]", ")", ";", "vec_safe_push", "(", "params", ",", "args", "[", "1", "]", ")", ";", "tree", "as_c_builtin", ";", "if", "(", "fcode", "==", "RS6000_OVLD_VEC_ADDEC", ")", "as_c_builtin", "=", "rs6000_builtin_decls", "[", "RS6000_OVLD_VEC_ADDC", "]", ";", "else", "as_c_builtin", "=", "rs6000_builtin_decls", "[", "RS6000_OVLD_VEC_SUBC", "]", ";", "tree", "call1", "=", "altivec_resolve_overloaded_builtin", "(", "loc", ",", "as_c_builtin", ",", "params", ")", ";", "params", "=", "make_tree_vector", "(", ")", ";", "vec_safe_push", "(", "params", ",", "args", "[", "0", "]", ")", ";", "vec_safe_push", "(", "params", ",", "args", "[", "1", "]", ")", ";", "tree", "as_builtin", ";", "if", "(", "fcode", "==", "RS6000_OVLD_VEC_ADDEC", ")", "as_builtin", "=", "rs6000_builtin_decls", "[", "RS6000_OVLD_VEC_ADD", "]", ";", "else", "as_builtin", "=", "rs6000_builtin_decls", "[", "RS6000_OVLD_VEC_SUB", "]", ";", "tree", "call2", "=", "altivec_resolve_overloaded_builtin", "(", "loc", ",", "as_builtin", ",", "params", ")", ";", "tree", "const1", "=", "build_int_cstu", "(", "TREE_TYPE", "(", "types", "[", "0", "]", ")", ",", "1", ")", ";", "tree", "ones_vector", "=", "build_vector_from_val", "(", "types", "[", "0", "]", ",", "const1", ")", ";", "tree", "and_expr", "=", "fold_build2_loc", "(", "loc", ",", "BIT_AND_EXPR", ",", "types", "[", "0", "]", ",", "args", "[", "2", "]", ",", "ones_vector", ")", ";", "params", "=", "make_tree_vector", "(", ")", ";", "vec_safe_push", "(", "params", ",", "call2", ")", ";", "vec_safe_push", "(", "params", ",", "and_expr", ")", ";", "call2", "=", "altivec_resolve_overloaded_builtin", "(", "loc", ",", "as_c_builtin", ",", "params", ")", ";", "params", "=", "make_tree_vector", "(", ")", ";", "vec_safe_push", "(", "params", ",", "call1", ")", ";", "vec_safe_push", "(", "params", ",", "call2", ")", ";", "tree", "or_builtin", "=", "rs6000_builtin_decls", "[", "RS6000_OVLD_VEC_OR", "]", ";", "*", "res", "=", "resolved", ";", "return", "altivec_resolve_overloaded_builtin", "(", "loc", ",", "or_builtin", ",", "params", ")", ";", "}", "case", "E_TImode", ":", "*", "res", "=", "unresolved", ";", "break", ";", "default", ":", "*", "res", "=", "resolved_bad", ";", "}", "return", "error_mark_node", ";", "}", "</s>" ]

[ "Resolve", "an", "overloaded", "vec_addec", "or", "vec_subec", "call", "and", "return", "a", "tree", "expression", "for", "the", "resolved", "call", "if", "successful", ".", "ARGS", "contains", "the", "arguments", "to", "the", "call", ".", "TYPES", "contains", "their", "types", ".", "RES", "must", "be", "set", "to", "indicate", "the", "status", "of", "the", "resolution", "attempt", ".", "LOC", "contains", "statement", "location", "information", "." ]

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

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "override", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "(", "4", "-", "i", "-", "1", ")", "*", "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", "." ]

[ "Sparc", "0", "4", "4", "1", "8", "0xff" ]

[]

[ "<s>", "static", "void", "alpha_override_options_after_change", "(", "void", ")", "{", "if", "(", "optimize", ">", "0", ")", "{", "if", "(", "align_loops", "<=", "0", ")", "align_loops", "=", "16", ";", "if", "(", "align_jumps", "<=", "0", ")", "align_jumps", "=", "16", ";", "}", "if", "(", "align_functions", "<=", "0", ")", "align_functions", "=", "16", ";", "}", "</s>" ]

[ "Implement", "targetm.override_options_after_change", "." ]

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

[]

[ "<s>", "static", "rtx", "legitimize_dllimport_symbol", "(", "rtx", "symbol", ",", "bool", "want_reg", ")", "{", "tree", "imp_decl", ";", "rtx", "x", ";", "gcc_assert", "(", "SYMBOL_REF_DECL", "(", "symbol", ")", ")", ";", "imp_decl", "=", "get_dllimport_decl", "(", "SYMBOL_REF_DECL", "(", "symbol", ")", ",", "true", ")", ";", "x", "=", "DECL_RTL", "(", "imp_decl", ")", ";", "if", "(", "want_reg", ")", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "Expand", "SYMBOL", "into", "its", "corresponding", "dllimport", "symbol", ".", "WANT_REG", "is", "true", "if", "we", "require", "the", "result", "be", "a", "register", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "aarch64_expand_vec_perm_1", "(", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "sel", ")", "{", "machine_mode", "vmode", "=", "GET_MODE", "(", "target", ")", ";", "bool", "one_vector_p", "=", "rtx_equal_p", "(", "op0", ",", "op1", ")", ";", "gcc_checking_assert", "(", "vmode", "==", "V8QImode", "||", "vmode", "==", "V16QImode", ")", ";", "gcc_checking_assert", "(", "GET_MODE", "(", "op0", ")", "==", "vmode", ")", ";", "gcc_checking_assert", "(", "GET_MODE", "(", "op1", ")", "==", "vmode", ")", ";", "gcc_checking_assert", "(", "GET_MODE", "(", "sel", ")", "==", "vmode", ")", ";", "gcc_checking_assert", "(", "TARGET_SIMD", ")", ";", "if", "(", "one_vector_p", ")", "{", "if", "(", "vmode", "==", "V8QImode", ")", "{", "rtx", "pair", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "emit_insn", "(", "gen_aarch64_combinev8qi", "(", "pair", ",", "op0", ",", "op0", ")", ")", ";", "emit_insn", "(", "gen_aarch64_tbl1v8qi", "(", "target", ",", "pair", ",", "sel", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_aarch64_tbl1v16qi", "(", "target", ",", "op0", ",", "sel", ")", ")", ";", "}", "}", "else", "{", "rtx", "pair", ";", "if", "(", "vmode", "==", "V8QImode", ")", "{", "pair", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "emit_insn", "(", "gen_aarch64_combinev8qi", "(", "pair", ",", "op0", ",", "op1", ")", ")", ";", "emit_insn", "(", "gen_aarch64_tbl1v8qi", "(", "target", ",", "pair", ",", "sel", ")", ")", ";", "}", "else", "{", "pair", "=", "gen_reg_rtx", "(", "OImode", ")", ";", "emit_insn", "(", "gen_aarch64_combinev16qi", "(", "pair", ",", "op0", ",", "op1", ")", ")", ";", "emit_insn", "(", "gen_aarch64_tbl2v16qi", "(", "target", ",", "pair", ",", "sel", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Generate", "a", "variable", "permutation", "." ]

[ "aarch64" ]

[]

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

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

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

[]

[ "<s>", "bool", "SIFixupVectorISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "Selected", ")", ")", "return", "false", ";", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "bool", "FuncModified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "FuncModified", "|=", "fixupGlobalSaddr", "(", "MBB", ",", "MF", ",", "MRI", ",", "ST", ",", "TII", ",", "TRI", ")", ";", "}", "return", "FuncModified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "length_fp_args", "(", "rtx_insn", "*", "insn", ")", "{", "int", "length", "=", "0", ";", "rtx", "link", ";", "for", "(", "link", "=", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ";", "link", ";", "link", "=", "XEXP", "(", "link", ",", "1", ")", ")", "{", "int", "arg_mode", ",", "regno", ";", "rtx", "use", "=", "XEXP", "(", "link", ",", "0", ")", ";", "if", "(", "!", "(", "GET_CODE", "(", "use", ")", "==", "USE", "&&", "GET_CODE", "(", "XEXP", "(", "use", ",", "0", ")", ")", "==", "REG", "&&", "FUNCTION_ARG_REGNO_P", "(", "REGNO", "(", "XEXP", "(", "use", ",", "0", ")", ")", ")", ")", ")", "continue", ";", "arg_mode", "=", "GET_MODE", "(", "XEXP", "(", "use", ",", "0", ")", ")", ";", "regno", "=", "REGNO", "(", "XEXP", "(", "use", ",", "0", ")", ")", ";", "if", "(", "regno", ">=", "32", "&&", "regno", "<=", "39", ")", "{", "if", "(", "arg_mode", "==", "SFmode", ")", "length", "+=", "8", ";", "else", "length", "+=", "12", ";", "}", "}", "return", "length", ";", "}", "</s>" ]

[ "Compute", "length", "of", "the", "FP", "argument", "copy", "sequence", "for", "INSN", "." ]

[ "pa", "0", "1", "0", "0", "0", "0", "0", "32", "39", "8", "12" ]

[]

[ "<s>", "ARMTargetLowering", "::", "ConstraintType", "ARMTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'l'", ":", "return", "C_RegisterClass", ";", "case", "'w'", ":", "return", "C_RegisterClass", ";", "case", "'h'", ":", "return", "C_RegisterClass", ";", "case", "'x'", ":", "return", "C_RegisterClass", ";", "case", "'t'", ":", "return", "C_RegisterClass", ";", "case", "'j'", ":", "return", "C_Other", ";", "case", "'Q'", ":", "return", "C_Memory", ";", "}", "}", "else", "if", "(", "Constraint", ".", "size", "(", ")", "==", "2", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'T'", ":", "return", "C_RegisterClass", ";", "case", "'U'", ":", "return", "C_Memory", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "1", "0", "2", "0" ]

[]

[ "<s>", "const", "uint32_t", "*", "X86RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "HasSSE", "=", "Subtarget", ".", "hasSSE1", "(", ")", ";", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "Subtarget", ".", "hasAVX512", "(", ")", ";", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_RegMask", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_RegMask", ";", "return", "CSR_64_AllRegs_RegMask", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_RegMask", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_RegMask", ";", "return", "CSR_64_RT_AllRegs_RegMask", ";", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_TLS_Darwin_RegMask", ";", "break", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_RegMask", ";", "break", ";", "}", "case", "CallingConv", "::", "HHVM", ":", "return", "CSR_64_HHVM_RegMask", ";", "case", "CallingConv", "::", "X86_RegCall", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "{", "return", "(", "HasSSE", "?", "CSR_Win64_RegCall_RegMask", ":", "CSR_Win64_RegCall_NoSSE_RegMask", ")", ";", "}", "else", "{", "return", "(", "HasSSE", "?", "CSR_SysV64_RegCall_RegMask", ":", "CSR_SysV64_RegCall_NoSSE_RegMask", ")", ";", "}", "}", "else", "{", "return", "(", "HasSSE", "?", "CSR_32_RegCall_RegMask", ":", "CSR_32_RegCall_NoSSE_RegMask", ")", ";", "}", "case", "CallingConv", "::", "CFGuard_Check", ":", "assert", "(", "!", "Is64Bit", "&&", "\"CFGuard check mechanism only used on 32-bit X86\"", ")", ";", "return", "(", "HasSSE", "?", "CSR_Win32_CFGuard_Check_RegMask", ":", "CSR_Win32_CFGuard_Check_NoSSE_RegMask", ")", ";", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_RegMask", ";", "break", ";", "case", "CallingConv", "::", "Win64", ":", "return", "CSR_Win64_RegMask", ";", "case", "CallingConv", "::", "SwiftTail", ":", "if", "(", "!", "Is64Bit", ")", "return", "CSR_32_RegMask", ";", "return", "IsWin64", "?", "CSR_Win64_SwiftTail_RegMask", ":", "CSR_64_SwiftTail_RegMask", ";", "case", "CallingConv", "::", "X86_64_SysV", ":", "return", "CSR_64_RegMask", ";", "case", "CallingConv", "::", "X86_INTR", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "HasAVX512", ")", "return", "CSR_64_AllRegs_AVX512_RegMask", ";", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_RegMask", ";", "if", "(", "HasSSE", ")", "return", "CSR_64_AllRegs_RegMask", ";", "return", "CSR_64_AllRegs_NoSSE_RegMask", ";", "}", "else", "{", "if", "(", "HasAVX512", ")", "return", "CSR_32_AllRegs_AVX512_RegMask", ";", "if", "(", "HasAVX", ")", "return", "CSR_32_AllRegs_AVX_RegMask", ";", "if", "(", "HasSSE", ")", "return", "CSR_32_AllRegs_SSE_RegMask", ";", "return", "CSR_32_AllRegs_RegMask", ";", "}", "default", ":", "break", ";", "}", "if", "(", "Is64Bit", ")", "{", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "IsSwiftCC", "=", "Subtarget", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "F", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ";", "if", "(", "IsSwiftCC", ")", "return", "IsWin64", "?", "CSR_Win64_SwiftError_RegMask", ":", "CSR_64_SwiftError_RegMask", ";", "return", "IsWin64", "?", "CSR_Win64_RegMask", ":", "CSR_64_RegMask", ";", "}", "return", "CSR_32_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "X86", "X86", "X86", "X86", "X86", "\"CFGuard check mechanism only used on 32-bit X86\"", "X86", "X86" ]

[]

[ "<s>", "static", "inline", "unsigned", "int", "avr_ret_register", "(", "void", ")", "{", "return", "24", ";", "}", "</s>" ]

[ "Returns", "register", "number", "for", "function", "return", "value", "." ]

[ "avr", "24" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "InfosBE", "[", "PPC", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_ppc_br24\"", ",", "6", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_br24_notoc\"", ",", "6", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_brcond14\"", ",", "16", ",", "14", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_br24abs\"", ",", "6", ",", "24", ",", "0", "}", ",", "{", "\"fixup_ppc_brcond14abs\"", ",", "16", ",", "14", ",", "0", "}", ",", "{", "\"fixup_ppc_half16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_ppc_half16ds\"", ",", "0", ",", "14", ",", "0", "}", ",", "{", "\"fixup_ppc_pcrel34\"", ",", "0", ",", "34", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_nofixup\"", ",", "0", ",", "0", ",", "0", "}", "}", ";", "const", "static", "MCFixupKindInfo", "InfosLE", "[", "PPC", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_ppc_br24\"", ",", "2", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_br24_notoc\"", ",", "2", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_brcond14\"", ",", "2", ",", "14", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_br24abs\"", ",", "2", ",", "24", ",", "0", "}", ",", "{", "\"fixup_ppc_brcond14abs\"", ",", "2", ",", "14", ",", "0", "}", ",", "{", "\"fixup_ppc_half16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_ppc_half16ds\"", ",", "2", ",", "14", ",", "0", "}", ",", "{", "\"fixup_ppc_pcrel34\"", ",", "0", ",", "34", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_nofixup\"", ",", "0", ",", "0", ",", "0", "}", "}", ";", "if", "(", "Kind", ">=", "FirstLiteralRelocationKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "FK_NONE", ")", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "(", "Endian", "==", "support", "::", "little", "?", "InfosLE", ":", "InfosBE", ")", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC::NumTargetFixupKinds", "\"fixup_ppc_br24\"", "6", "24", "\"fixup_ppc_br24_notoc\"", "6", "24", "\"fixup_ppc_brcond14\"", "16", "14", "\"fixup_ppc_br24abs\"", "6", "24", "0", "\"fixup_ppc_brcond14abs\"", "16", "14", "0", "\"fixup_ppc_half16\"", "0", "16", "0", "\"fixup_ppc_half16ds\"", "0", "14", "0", "\"fixup_ppc_pcrel34\"", "0", "34", "\"fixup_ppc_nofixup\"", "0", "0", "0", "PPC::NumTargetFixupKinds", "\"fixup_ppc_br24\"", "2", "24", "\"fixup_ppc_br24_notoc\"", "2", "24", "\"fixup_ppc_brcond14\"", "2", "14", "\"fixup_ppc_br24abs\"", "2", "24", "0", "\"fixup_ppc_brcond14abs\"", "2", "14", "0", "\"fixup_ppc_half16\"", "0", "16", "0", "\"fixup_ppc_half16ds\"", "2", "14", "0", "\"fixup_ppc_pcrel34\"", "0", "34", "\"fixup_ppc_nofixup\"", "0", "0", "0", "\"Invalid kind!\"", "support::little" ]

[]

[ "<s>", "static", "bool", "arm_fixed_condition_code_regs", "(", "unsigned", "int", "*", "p1", ",", "unsigned", "int", "*", "p2", ")", "{", "if", "(", "!", "TARGET_32BIT", ")", "return", "false", ";", "*", "p1", "=", "CC_REGNUM", ";", "*", "p2", "=", "TARGET_HARD_FLOAT", "?", "VFPCC_REGNUM", ":", "INVALID_REGNUM", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_FIXED_CONDITION_CODE_REGS", ".", "We", "only", "have", "condition", "code", "registers", "when", "not", "targetting", "Thumb1", ".", "The", "VFP", "condition", "register", "only", "exists", "when", "generating", "hard-float", "code", "." ]

[ "arm" ]

[]

[ "<s>", "static", "const", "char", "*", "rs6000_invalid_binary_op", "(", "int", "op", "ATTRIBUTE_UNUSED", ",", "const_tree", "type1", ",", "const_tree", "type2", ")", "{", "machine_mode", "mode1", "=", "TYPE_MODE", "(", "type1", ")", ";", "machine_mode", "mode2", "=", "TYPE_MODE", "(", "type2", ")", ";", "if", "(", "COMPLEX_MODE_P", "(", "mode1", ")", ")", "mode1", "=", "GET_MODE_INNER", "(", "mode1", ")", ";", "if", "(", "COMPLEX_MODE_P", "(", "mode2", ")", ")", "mode2", "=", "GET_MODE_INNER", "(", "mode2", ")", ";", "if", "(", "mode1", "==", "mode2", ")", "return", "NULL", ";", "if", "(", "!", "TARGET_FLOAT128_CVT", ")", "{", "if", "(", "(", "FLOAT128_IEEE_P", "(", "mode1", ")", "&&", "FLOAT128_IBM_P", "(", "mode2", ")", ")", "||", "(", "FLOAT128_IBM_P", "(", "mode1", ")", "&&", "FLOAT128_IEEE_P", "(", "mode2", ")", ")", ")", "return", "N_", "(", "\"Invalid mixing of IEEE 128-bit and IBM 128-bit floating \"", "\"point types\"", ")", ";", "}", "return", "NULL", ";", "}", "</s>" ]

[ "Return", "the", "diagnostic", "message", "string", "if", "the", "binary", "operation", "OP", "is", "not", "permitted", "on", "TYPE1", "and", "TYPE2", ",", "NULL", "otherwise", "." ]

[ "rs6000", "\"Invalid mixing of IEEE 128-bit and IBM 128-bit floating \"", "\"point types\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 Domain Reassignment Pass\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Domain Reassignment Pass\"" ]

[]

[ "<s>", "EVT", "ARMTargetLowering", "::", "getOptimalMemOpType", "(", "const", "MemOp", "&", "Op", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "{", "if", "(", "(", "Op", ".", "isMemcpy", "(", ")", "||", "Op", ".", "isZeroMemset", "(", ")", ")", "&&", "Subtarget", "->", "hasNEON", "(", ")", "&&", "!", "FuncAttributes", ".", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ")", "{", "bool", "Fast", ";", "if", "(", "Op", ".", "size", "(", ")", ">=", "16", "&&", "(", "Op", ".", "isAligned", "(", "Align", "(", "16", ")", ")", "||", "(", "allowsMisalignedMemoryAccesses", "(", "MVT", "::", "v2f64", ",", "0", ",", "Align", "(", "1", ")", ",", "MachineMemOperand", "::", "MONone", ",", "&", "Fast", ")", "&&", "Fast", ")", ")", ")", "{", "return", "MVT", "::", "v2f64", ";", "}", "else", "if", "(", "Op", ".", "size", "(", ")", ">=", "8", "&&", "(", "Op", ".", "isAligned", "(", "Align", "(", "8", ")", ")", "||", "(", "allowsMisalignedMemoryAccesses", "(", "MVT", "::", "f64", ",", "0", ",", "Align", "(", "1", ")", ",", "MachineMemOperand", "::", "MONone", ",", "&", "Fast", ")", "&&", "Fast", ")", ")", ")", "{", "return", "MVT", "::", "f64", ";", "}", "}", "return", "MVT", "::", "Other", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "16", "16", "MVT::v2f64", "0", "1", "MVT::v2f64", "8", "8", "MVT::f64", "0", "1", "MVT::f64", "MVT::Other" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"X86 Atom pad short functions\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Atom pad short functions\"" ]

[]

[ "<s>", "unsigned", "MSP430InstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugInstr", "(", ")", ")", "continue", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "MSP430", "::", "JMP", "&&", "I", "->", "getOpcode", "(", ")", "!=", "MSP430", "::", "JCC", "&&", "I", "->", "getOpcode", "(", ")", "!=", "MSP430", "::", "Bi", "&&", "I", "->", "getOpcode", "(", ")", "!=", "MSP430", "::", "Br", "&&", "I", "->", "getOpcode", "(", ")", "!=", "MSP430", "::", "Bm", ")", "break", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "\"code size not handled\"", "0", "MSP430::JMP", "MSP430::JCC", "MSP430::Bi", "MSP430::Br", "MSP430::Bm" ]

[]

[ "<s>", "static", "void", "get_scratch_register_on_entry", "(", "struct", "scratch_reg", "*", "sr", ",", "unsigned", "int", "regno1", ",", "unsigned", "long", "live_regs", ")", "{", "int", "regno", "=", "-", "1", ";", "sr", "->", "saved", "=", "false", ";", "if", "(", "regno1", "!=", "LR_REGNUM", "&&", "(", "live_regs", "&", "(", "1", "<<", "LR_REGNUM", ")", ")", "!=", "0", ")", "regno", "=", "LR_REGNUM", ";", "else", "{", "unsigned", "int", "i", ";", "for", "(", "i", "=", "4", ";", "i", "<", "11", ";", "i", "++", ")", "if", "(", "regno1", "!=", "i", "&&", "(", "live_regs", "&", "(", "1", "<<", "i", ")", ")", "!=", "0", ")", "{", "regno", "=", "i", ";", "break", ";", "}", "if", "(", "regno", "<", "0", ")", "{", "if", "(", "regno1", "==", "IP_REGNUM", "&&", "IS_NESTED", "(", "arm_current_func_type", "(", ")", ")", ")", "regno1", "=", "3", ";", "regno", "=", "(", "regno1", "==", "3", "?", "2", ":", "3", ")", ";", "sr", "->", "saved", "=", "REGNO_REG_SET_P", "(", "df_get_live_out", "(", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ")", ",", "regno", ")", ";", "}", "}", "sr", "->", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "if", "(", "sr", "->", "saved", ")", "{", "rtx", "addr", "=", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ";", "rtx", "insn", "=", "emit_set_insn", "(", "gen_frame_mem", "(", "SImode", ",", "addr", ")", ",", "sr", "->", "reg", ")", ";", "rtx", "x", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "4", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "x", ")", ";", "}", "}", "</s>" ]

[ "Return", "a", "short-lived", "scratch", "register", "for", "use", "on", "function", "entry", ".", "In", "32-bit", "mode", ",", "it", "is", "valid", "only", "after", "the", "registers", "are", "saved", "in", "the", "prologue", ".", "This", "register", "must", "be", "released", "by", "means", "of", "release_scratch_register_on_entry", "once", "it", "is", "dead", "." ]

[ "arm", "1", "1", "0", "4", "11", "1", "0", "0", "3", "3", "2", "3", "4", "1" ]

[]

[ "<s>", "void", "AMDGPUTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "APInt", "&", "KnownZero", ",", "APInt", "&", "KnownOne", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "BitWidth", "=", "KnownZero", ".", "getBitWidth", "(", ")", ";", "KnownZero", "=", "KnownOne", "=", "APInt", "(", "BitWidth", ",", "0", ")", ";", "APInt", "KnownZero2", ";", "APInt", "KnownOne2", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "AMDGPUISD", "::", "CARRY", ":", "case", "AMDGPUISD", "::", "BORROW", ":", "{", "KnownZero", "=", "APInt", "::", "getHighBitsSet", "(", "32", ",", "31", ")", ";", "break", ";", "}", "case", "AMDGPUISD", "::", "BFE_I32", ":", "case", "AMDGPUISD", "::", "BFE_U32", ":", "{", "ConstantSDNode", "*", "CWidth", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "if", "(", "!", "CWidth", ")", "return", ";", "uint32_t", "Width", "=", "CWidth", "->", "getZExtValue", "(", ")", "&", "0x1f", ";", "if", "(", "Opc", "==", "AMDGPUISD", "::", "BFE_U32", ")", "KnownZero", "=", "APInt", "::", "getHighBitsSet", "(", "32", ",", "32", "-", "Width", ")", ";", "break", ";", "}", "case", "AMDGPUISD", "::", "FP_TO_FP16", ":", "case", "AMDGPUISD", "::", "FP16_ZEXT", ":", "{", "unsigned", "BitWidth", "=", "KnownZero", ".", "getBitWidth", "(", ")", ";", "KnownZero", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "16", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "0", "AMDGPUISD::CARRY", "AMDGPUISD::BORROW", "32", "31", "AMDGPUISD::BFE_I32", "AMDGPUISD::BFE_U32", "2", "0x1f", "AMDGPUISD::BFE_U32", "32", "32", "AMDGPUISD::FP_TO_FP16", "AMDGPUISD::FP16_ZEXT", "16" ]

[]

[ "<s>", "static", "bool", "arm_can_output_mi_thunk", "(", "const_tree", ",", "HOST_WIDE_INT", ",", "HOST_WIDE_INT", "vcall_offset", ",", "const_tree", ")", "{", "if", "(", "vcall_offset", "&&", "TARGET_THUMB1", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Can", "output", "mi_thunk", "for", "all", "cases", "except", "for", "non-zero", "vcall_offset", "in", "Thumb1", "." ]

[ "arm" ]

[]

[ "<s>", "void", "XCoreTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "KnownBits", "&", "Known", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "Known", ".", "resetAll", "(", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "XCoreISD", "::", "LADD", ":", "case", "XCoreISD", "::", "LSUB", ":", "if", "(", "Op", ".", "getResNo", "(", ")", "==", "1", ")", "{", "Known", ".", "Zero", "=", "APInt", "::", "getHighBitsSet", "(", "Known", ".", "getBitWidth", "(", ")", ",", "Known", ".", "getBitWidth", "(", ")", "-", "1", ")", ";", "}", "break", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "unsigned", "IntNo", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", ";", "switch", "(", "IntNo", ")", "{", "case", "Intrinsic", "::", "xcore_getts", ":", "Known", ".", "Zero", "=", "APInt", "::", "getHighBitsSet", "(", "Known", ".", "getBitWidth", "(", ")", ",", "Known", ".", "getBitWidth", "(", ")", "-", "16", ")", ";", "break", ";", "case", "Intrinsic", "::", "xcore_int", ":", "case", "Intrinsic", "::", "xcore_inct", ":", "Known", ".", "Zero", "=", "APInt", "::", "getHighBitsSet", "(", "Known", ".", "getBitWidth", "(", ")", ",", "Known", ".", "getBitWidth", "(", ")", "-", "8", ")", ";", "break", ";", "case", "Intrinsic", "::", "xcore_testct", ":", "Known", ".", "Zero", "=", "APInt", "::", "getHighBitsSet", "(", "Known", ".", "getBitWidth", "(", ")", ",", "Known", ".", "getBitWidth", "(", ")", "-", "1", ")", ";", "break", ";", "case", "Intrinsic", "::", "xcore_testwct", ":", "Known", ".", "Zero", "=", "APInt", "::", "getHighBitsSet", "(", "Known", ".", "getBitWidth", "(", ")", ",", "Known", ".", "getBitWidth", "(", ")", "-", "3", ")", ";", "break", ";", "}", "}", "break", ";", "}", "}", "</s>" ]

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

[ "XCore", "XCore", "XCoreISD::LADD", "XCoreISD::LSUB", "1", "1", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::xcore_getts", "16", "Intrinsic::xcore_int", "Intrinsic::xcore_inct", "8", "Intrinsic::xcore_testct", "1", "Intrinsic::xcore_testwct", "3" ]

[]

[ "<s>", "rtx", "create_TOC_reference", "(", "rtx", "symbol", ",", "rtx", "largetoc_reg", ")", "{", "rtx", "tocrel", ",", "tocreg", ",", "hi", ";", "if", "(", "TARGET_DEBUG_ADDR", ")", "{", "if", "(", "GET_CODE", "(", "symbol", ")", "==", "SYMBOL_REF", ")", "fprintf", "(", "stderr", ",", "\"\\ncreate_TOC_reference, (symbol_ref %s)\\n\"", ",", "XSTR", "(", "symbol", ",", "0", ")", ")", ";", "else", "{", "fprintf", "(", "stderr", ",", "\"\\ncreate_TOC_reference, code %s:\\n\"", ",", "GET_RTX_NAME", "(", "GET_CODE", "(", "symbol", ")", ")", ")", ";", "debug_rtx", "(", "symbol", ")", ";", "}", "}", "if", "(", "!", "can_create_pseudo_p", "(", ")", ")", "df_set_regs_ever_live", "(", "TOC_REGISTER", ",", "true", ")", ";", "tocreg", "=", "gen_rtx_REG", "(", "Pmode", ",", "TOC_REGISTER", ")", ";", "tocrel", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "2", ",", "symbol", ",", "tocreg", ")", ",", "UNSPEC_TOCREL", ")", ";", "if", "(", "TARGET_CMODEL", "==", "CMODEL_SMALL", "||", "can_create_pseudo_p", "(", ")", ")", "return", "tocrel", ";", "hi", "=", "gen_rtx_HIGH", "(", "Pmode", ",", "copy_rtx", "(", "tocrel", ")", ")", ";", "if", "(", "largetoc_reg", "!=", "NULL", ")", "{", "emit_move_insn", "(", "largetoc_reg", ",", "hi", ")", ";", "hi", "=", "largetoc_reg", ";", "}", "return", "gen_rtx_LO_SUM", "(", "Pmode", ",", "hi", ",", "tocrel", ")", ";", "}", "</s>" ]

[ "Create", "a", "TOC", "reference", "for", "symbol_ref", "SYMBOL", ".", "If", "LARGETOC_REG", "is", "non-null", ",", "use", "that", "as", "the", "register", "to", "put", "the", "HIGH", "value", "into", "if", "register", "allocation", "is", "already", "done", "." ]

[ "rs6000", "\"\\ncreate_TOC_reference, (symbol_ref %s)\\n\"", "0", "\"\\ncreate_TOC_reference, code %s:\\n\"", "2" ]

[]

[ "<s>", "void", "aarch64_split_simd_move", "(", "rtx", "dst", ",", "rtx", "src", ")", "{", "machine_mode", "src_mode", "=", "GET_MODE", "(", "src", ")", ";", "machine_mode", "dst_mode", "=", "GET_MODE", "(", "dst", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "dst_mode", ")", ")", ";", "if", "(", "REG_P", "(", "dst", ")", "&&", "REG_P", "(", "src", ")", ")", "{", "gcc_assert", "(", "VECTOR_MODE_P", "(", "src_mode", ")", ")", ";", "emit_insn", "(", "gen_aarch64_split_simd_mov", "(", "src_mode", ",", "dst", ",", "src", ")", ")", ";", "}", "}", "</s>" ]

[ "Split", "a", "complex", "SIMD", "move", "." ]

[ "aarch64" ]

[]

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

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

[ "P2", "P2", "P2" ]

[]

[ "<s>", "static", "rtx", "sh_trampoline_adjust_address", "(", "rtx", "tramp", ")", "{", "if", "(", "TARGET_SHMEDIA", ")", "tramp", "=", "expand_simple_binop", "(", "Pmode", ",", "PLUS", ",", "tramp", ",", "const1_rtx", ",", "gen_reg_rtx", "(", "Pmode", ")", ",", "0", ",", "OPTAB_LIB_WIDEN", ")", ";", "return", "tramp", ";", "}", "</s>" ]

[ "On", "SH5", ",", "trampolines", "are", "SHmedia", "code", ",", "so", "add", "1", "to", "the", "address", "." ]

[ "sh", "0" ]

[]

[ "<s>", "int", "extra_constraint_Q", "(", "rtx", "x", ")", "{", "int", "ok", "=", "0", ";", "rtx", "plus", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "plus", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "plus", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "plus", ",", "1", ")", ")", "&&", "(", "INTVAL", "(", "XEXP", "(", "plus", ",", "1", ")", ")", "<=", "MAX_LD_OFFSET", "(", "GET_MODE", "(", "x", ")", ")", ")", ")", "{", "rtx", "xx", "=", "XEXP", "(", "plus", ",", "0", ")", ";", "int", "regno", "=", "REGNO", "(", "xx", ")", ";", "ok", "=", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", "||", "regno", "==", "REG_Z", "||", "regno", "==", "REG_Y", "||", "xx", "==", "frame_pointer_rtx", "||", "xx", "==", "arg_pointer_rtx", ")", ";", "if", "(", "avr_log", ".", "constraints", ")", "avr_edump", "(", "\"\\n%?=%d reload_completed=%d reload_in_progress=%d\\n %r\\n\"", ",", "ok", ",", "reload_completed", ",", "reload_in_progress", ",", "x", ")", ";", "}", "return", "ok", ";", "}", "</s>" ]

[ "Test", "for", "extra", "memory", "constraint", "'", "Q", "'", ".", "It", "'s", "a", "memory", "address", "based", "on", "Y", "or", "Z", "pointer", "with", "valid", "displacement", "." ]

[ "avr", "0", "0", "0", "1", "1", "0", "\"\\n%?=%d reload_completed=%d reload_in_progress=%d\\n %r\\n\"" ]

[]

[ "<s>", "static", "bool", "pdp11_secondary_memory_needed", "(", "machine_mode", ",", "reg_class_t", "c1", ",", "reg_class_t", "c2", ")", "{", "int", "fromfloat", "=", "(", "c1", "==", "LOAD_FPU_REGS", "||", "c1", "==", "NO_LOAD_FPU_REGS", "||", "c1", "==", "FPU_REGS", ")", ";", "int", "tofloat", "=", "(", "c2", "==", "LOAD_FPU_REGS", "||", "c2", "==", "NO_LOAD_FPU_REGS", "||", "c2", "==", "FPU_REGS", ")", ";", "return", "(", "fromfloat", "!=", "tofloat", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SECONDARY_MEMORY_NEEDED", ".", "The", "answer", "is", "yes", "if", "we", "'re", "going", "between", "general", "register", "and", "FPU", "registers", ".", "The", "mode", "does", "n't", "matter", "in", "making", "this", "check", "." ]

[ "pdp11" ]

[]

[ "<s>", "void", "visitCallInst", "(", "CallInst", "&", "I", ")", "{", "if", "(", "!", "I", ".", "getCalledFunction", "(", ")", ")", "return", ";", "StringRef", "Name", "=", "I", ".", "getCalledFunction", "(", ")", "->", "getName", "(", ")", ";", "if", "(", "Name", "==", "\"llvm.AMDGPU.tex\"", ")", "{", "ReplaceTexIntrinsic", "(", "I", ",", "false", ",", "TexSign", ",", "\"llvm.R600.tex\"", ",", "\"llvm.R600.texc\"", ")", ";", "return", ";", "}", "if", "(", "Name", "==", "\"llvm.AMDGPU.txl\"", ")", "{", "ReplaceTexIntrinsic", "(", "I", ",", "true", ",", "TexSign", ",", "\"llvm.R600.txl\"", ",", "\"llvm.R600.txlc\"", ")", ";", "return", ";", "}", "if", "(", "Name", "==", "\"llvm.AMDGPU.txb\"", ")", "{", "ReplaceTexIntrinsic", "(", "I", ",", "true", ",", "TexSign", ",", "\"llvm.R600.txb\"", ",", "\"llvm.R600.txbc\"", ")", ";", "return", ";", "}", "if", "(", "Name", "==", "\"llvm.AMDGPU.txf\"", ")", "{", "ReplaceTXF", "(", "I", ")", ";", "return", ";", "}", "if", "(", "Name", "==", "\"llvm.AMDGPU.txq\"", ")", "{", "ReplaceTexIntrinsic", "(", "I", ",", "false", ",", "TexQSign", ",", "\"llvm.R600.txq\"", ",", "\"llvm.R600.txq\"", ")", ";", "return", ";", "}", "if", "(", "Name", "==", "\"llvm.AMDGPU.ddx\"", ")", "{", "ReplaceTexIntrinsic", "(", "I", ",", "false", ",", "TexSign", ",", "\"llvm.R600.ddx\"", ",", "\"llvm.R600.ddx\"", ")", ";", "return", ";", "}", "if", "(", "Name", "==", "\"llvm.AMDGPU.ddy\"", ")", "{", "ReplaceTexIntrinsic", "(", "I", ",", "false", ",", "TexSign", ",", "\"llvm.R600.ddy\"", ",", "\"llvm.R600.ddy\"", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "CallInst", "simplification", "." ]

[ "AMDGPU", "\"llvm.AMDGPU.tex\"", "\"llvm.R600.tex\"", "\"llvm.R600.texc\"", "\"llvm.AMDGPU.txl\"", "\"llvm.R600.txl\"", "\"llvm.R600.txlc\"", "\"llvm.AMDGPU.txb\"", "\"llvm.R600.txb\"", "\"llvm.R600.txbc\"", "\"llvm.AMDGPU.txf\"", "\"llvm.AMDGPU.txq\"", "\"llvm.R600.txq\"", "\"llvm.R600.txq\"", "\"llvm.AMDGPU.ddx\"", "\"llvm.R600.ddx\"", "\"llvm.R600.ddx\"", "\"llvm.AMDGPU.ddy\"", "\"llvm.R600.ddy\"", "\"llvm.R600.ddy\"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "override", "{", "bool", "Changed", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "F", ".", "begin", "(", ")", ",", "FE", "=", "F", ".", "end", "(", ")", ";", "FI", "!=", "FE", ";", "++", "FI", ")", "{", "Changed", "|=", "runOnMachineBasicBlock", "(", "*", "FI", ")", ";", "FISCTextSectOffset", "+=", "FI", "->", "size", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "FISC", "FISC" ]

[]

[ "<s>", "void", "push", "(", "const", "pseudo_node_t", "&", "back", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Pushing backedge %d:%+d\\n\"", ",", "back", ".", "first", "?", "back", ".", "first", "->", "index", ":", "0", ",", "back", ".", "second", ")", ";", "brackets", ".", "safe_push", "(", "bracket", "(", "back", ")", ")", ";", "}", "</s>" ]

[ "Output", "RTL", "to", "push", "register", "RN", "onto", "the", "stack", "." ]

[ "nvptx", "\"Pushing backedge %d:%+d\\n\"", "0" ]

[]

[ "<s>", "unsigned", "SparcAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "GOp", ",", "unsigned", "Kind", ")", "{", "SparcOperand", "&", "Op", "=", "(", "SparcOperand", "&", ")", "GOp", ";", "if", "(", "Op", ".", "isFloatOrDoubleReg", "(", ")", ")", "{", "switch", "(", "Kind", ")", "{", "default", ":", "break", ";", "case", "MCK_DFPRegs", ":", "if", "(", "!", "Op", ".", "isFloatReg", "(", ")", "||", "SparcOperand", "::", "MorphToDoubleReg", "(", "Op", ")", ")", "return", "MCTargetAsmParser", "::", "Match_Success", ";", "break", ";", "case", "MCK_QFPRegs", ":", "if", "(", "SparcOperand", "::", "MorphToQuadReg", "(", "Op", ")", ")", "return", "MCTargetAsmParser", "::", "Match_Success", ";", "break", ";", "}", "}", "if", "(", "Op", ".", "isIntReg", "(", ")", "&&", "Kind", "==", "MCK_IntPair", ")", "{", "if", "(", "SparcOperand", "::", "MorphToIntPairReg", "(", "Op", ")", ")", "return", "MCTargetAsmParser", "::", "Match_Success", ";", "}", "if", "(", "Op", ".", "isCoprocReg", "(", ")", "&&", "Kind", "==", "MCK_CoprocPair", ")", "{", "if", "(", "SparcOperand", "::", "MorphToCoprocPairReg", "(", "Op", ")", ")", "return", "MCTargetAsmParser", "::", "Match_Success", ";", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "Sparc", "Sparc", "Sparc", "Sparc", "SparcOperand::MorphToDoubleReg", "SparcOperand::MorphToQuadReg", "SparcOperand::MorphToIntPairReg", "SparcOperand::MorphToCoprocPairReg" ]

[]

[ "<s>", "static", "bool", "rs6000_parm_needs_stack", "(", "cumulative_args_t", "args_so_far", ",", "tree", "type", ")", "{", "int", "unsignedp", ";", "rtx", "entry_parm", ";", "if", "(", "type", "==", "NULL", "||", "type", "==", "error_mark_node", ")", "return", "true", ";", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "VOIDmode", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", ")", "return", "(", "rs6000_parm_needs_stack", "(", "args_so_far", ",", "TREE_TYPE", "(", "type", ")", ")", "||", "rs6000_parm_needs_stack", "(", "args_so_far", ",", "TREE_TYPE", "(", "type", ")", ")", ")", ";", "if", "(", "(", "TREE_CODE", "(", "type", ")", "==", "UNION_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", ")", "&&", "TYPE_TRANSPARENT_AGGR", "(", "type", ")", ")", "type", "=", "TREE_TYPE", "(", "first_field", "(", "type", ")", ")", ";", "function_arg_info", "arg", "(", "type", ",", "true", ")", ";", "apply_pass_by_reference_rules", "(", "get_cumulative_args", "(", "args_so_far", ")", ",", "arg", ")", ";", "unsignedp", "=", "TYPE_UNSIGNED", "(", "type", ")", ";", "arg", ".", "mode", "=", "promote_mode", "(", "arg", ".", "type", ",", "arg", ".", "mode", ",", "&", "unsignedp", ")", ";", "if", "(", "rs6000_must_pass_in_stack", "(", "arg", ")", ")", "return", "true", ";", "entry_parm", "=", "rs6000_function_arg", "(", "args_so_far", ",", "arg", ")", ";", "if", "(", "entry_parm", "==", "NULL", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "entry_parm", ")", "==", "PARALLEL", "&&", "XEXP", "(", "XVECEXP", "(", "entry_parm", ",", "0", ",", "0", ")", ",", "0", ")", "==", "NULL_RTX", ")", "return", "true", ";", "if", "(", "rs6000_arg_partial_bytes", "(", "args_so_far", ",", "arg", ")", "!=", "0", ")", "return", "true", ";", "rs6000_function_arg_advance", "(", "args_so_far", ",", "arg", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Process", "parameter", "of", "type", "TYPE", "after", "ARGS_SO_FAR", "parameters", "were", "already", "processes", ".", "Return", "true", "if", "the", "parameter", "must", "be", "passed", "(", "fully", "or", "partially", ")", "on", "the", "stack", "." ]

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

[]

[ "<s>", "bool", "ARMFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "bool", "isVarArg", "=", "AFI", "->", "getArgRegsSaveSize", "(", ")", ">", "0", ";", "unsigned", "NumAlignedDPRCS2Regs", "=", "AFI", "->", "getNumAlignedDPRCS2Regs", "(", ")", ";", "if", "(", "NumAlignedDPRCS2Regs", ")", "emitAlignedDPRCS2Restores", "(", "MBB", ",", "MI", ",", "NumAlignedDPRCS2Regs", ",", "CSI", ",", "TRI", ")", ";", "unsigned", "PopOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2LDMIA_UPD", ":", "ARM", "::", "LDMIA_UPD", ";", "unsigned", "LdrOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2LDR_POST", ":", "ARM", "::", "LDR_POST_IMM", ";", "unsigned", "FltOpc", "=", "ARM", "::", "VLDMDIA_UPD", ";", "emitPopInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "FltOpc", ",", "0", ",", "isVarArg", ",", "true", ",", "&", "isARMArea3Register", ",", "NumAlignedDPRCS2Regs", ")", ";", "emitPopInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PopOpc", ",", "LdrOpc", ",", "isVarArg", ",", "false", ",", "&", "isARMArea2Register", ",", "0", ")", ";", "emitPopInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PopOpc", ",", "LdrOpc", ",", "isVarArg", ",", "false", ",", "&", "isARMArea1Register", ",", "0", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "0", "ARM::t2LDMIA_UPD", "ARM::LDMIA_UPD", "ARM::t2LDR_POST", "ARM::LDR_POST_IMM", "ARM::VLDMDIA_UPD", "0", "ARM", "ARM", "0", "ARM", "0" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", "||", "!", "RunPreEmitPeephole", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "const", "PPCInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "SmallVector", "<", "MachineInstr", "*", ",", "4", ">", "InstrsToErase", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "MachineInstr", "*", "DefMIToErase", "=", "nullptr", ";", "if", "(", "TII", "->", "convertToImmediateForm", "(", "MI", ",", "&", "DefMIToErase", ")", ")", "{", "Changed", "=", "true", ";", "NumRRConvertedInPreEmit", "++", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Converted instruction to imm form: \"", ")", ";", "LLVM_DEBUG", "(", "MI", ".", "dump", "(", ")", ")", ";", "if", "(", "DefMIToErase", ")", "{", "InstrsToErase", ".", "push_back", "(", "DefMIToErase", ")", ";", "}", "}", "}", "}", "for", "(", "MachineInstr", "*", "MI", ":", "InstrsToErase", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"PPC pre-emit peephole: erasing instruction: \"", ")", ";", "LLVM_DEBUG", "(", "MI", "->", "dump", "(", ")", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "NumRemovedInPreEmit", "++", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "4", "\"Converted instruction to imm form: \"", "\"PPC pre-emit peephole: erasing instruction: \"" ]

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createAMDGPUISelDag", "(", "getAMDGPUTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "rtx", "s390_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "fun", "ATTRIBUTE_UNUSED", ")", "{", "return", "s390_function_and_libcall_value", "(", "mode", ",", "NULL_TREE", ",", "NULL_TREE", ",", "true", ")", ";", "}", "</s>" ]

[ "Define", "where", "to", "return", "a", "scalar", "libcall", "return", "value", "of", "mode", "MODE", "." ]

[ "s390" ]

[]

[ "<s>", "BitVector", "Nios2RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "1", ")", ";", "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", "." ]

[ "Nios2", "Nios2", "1" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Function: \"", ";", "MF", ".", "dump", "(", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "initialize", "(", "MF", ")", ";", "if", "(", "!", "collectISELInstructions", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"No ISEL instructions in this function\\n\"", ")", ";", "return", "false", ";", "}", "DumpISELInstructions", "(", ")", ";", "expandAndMergeISELs", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "\"Function: \"", "\"\\n\"", "\"No ISEL instructions in this function\\n\"" ]

[]

[ "<s>", "int", "reg_or_0_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "CONST_INT", ":", "return", "INTVAL", "(", "op", ")", "==", "0", ";", "case", "REG", ":", "case", "SUBREG", ":", "return", "register_operand", "(", "op", ",", "mode", ")", ";", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "either", "a", "register", "or", "0" ]

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

[]

[ "<s>", "static", "enum", "attr_op_type", "sched_address_type", "(", "machine_mode", "mode", ",", "rtx", "addr_rtx", ")", "{", "struct", "m68k_address", "address", ";", "if", "(", "symbolic_operand", "(", "addr_rtx", ",", "VOIDmode", ")", ")", "return", "OP_TYPE_MEM7", ";", "if", "(", "!", "m68k_decompose_address", "(", "mode", ",", "addr_rtx", ",", "reload_completed", ",", "&", "address", ")", ")", "{", "gcc_assert", "(", "!", "reload_completed", ")", ";", "return", "OP_TYPE_MEM234", ";", "}", "if", "(", "address", ".", "scale", "!=", "0", ")", "return", "OP_TYPE_MEM6", ";", "if", "(", "address", ".", "base", "!=", "NULL_RTX", ")", "{", "if", "(", "address", ".", "offset", "==", "NULL_RTX", ")", "return", "OP_TYPE_MEM234", ";", "return", "OP_TYPE_MEM5", ";", "}", "gcc_assert", "(", "address", ".", "offset", "!=", "NULL_RTX", ")", ";", "return", "OP_TYPE_MEM7", ";", "}", "</s>" ]

[ "Return", "type", "of", "memory", "ADDR_RTX", "refers", "to", "." ]

[ "m68k", "0" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequiredID", "(", "LoopSimplifyID", ")", ";", "AU", ".", "addRequiredID", "(", "LCSSAID", ")", ";", "AU", ".", "addRequired", "<", "AAResultsWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "AAResultsWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "static", "int", "supersparc_adjust_cost", "(", "rtx", "insn", ",", "rtx", "link", ",", "rtx", "dep_insn", ",", "int", "cost", ")", "{", "enum", "attr_type", "insn_type", ";", "if", "(", "!", "recog_memoized", "(", "insn", ")", ")", "return", "0", ";", "insn_type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "==", "0", ")", "{", "if", "(", "insn_type", "==", "TYPE_LOAD", "||", "insn_type", "==", "TYPE_FPLOAD", ")", "return", "cost", "+", "3", ";", "if", "(", "insn_type", "==", "TYPE_STORE", "||", "insn_type", "==", "TYPE_FPSTORE", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "dep_pat", "=", "PATTERN", "(", "dep_insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", "||", "GET_CODE", "(", "dep_pat", ")", "!=", "SET", ")", "return", "cost", ";", "if", "(", "rtx_equal_p", "(", "SET_DEST", "(", "dep_pat", ")", ",", "SET_SRC", "(", "pat", ")", ")", ")", "return", "cost", ";", "return", "cost", "+", "3", ";", "}", "if", "(", "insn_type", "==", "TYPE_SHIFT", ")", "return", "cost", "+", "3", ";", "}", "else", "{", "if", "(", "insn_type", "==", "TYPE_IALU", "||", "insn_type", "==", "TYPE_SHIFT", ")", "return", "0", ";", "}", "return", "cost", ";", "}", "</s>" ]

[ "Adjust", "the", "cost", "of", "a", "scheduling", "dependency", ".", "Return", "the", "new", "cost", "of", "a", "dependency", "LINK", "or", "INSN", "on", "DEP_INSN", ".", "COST", "is", "the", "current", "cost", "." ]

[ "sparc", "0", "0", "3", "3", "3", "0" ]

[]

[ "<s>", "const", "MCExpr", "*", "X86_64MachoTargetObjectFile", "::", "getIndirectSymViaGOTPCRel", "(", "const", "GlobalValue", "*", "GV", ",", "const", "MCSymbol", "*", "Sym", ",", "const", "MCValue", "&", "MV", ",", "int64_t", "Offset", ",", "MachineModuleInfo", "*", "MMI", ",", "MCStreamer", "&", "Streamer", ")", "const", "{", "unsigned", "FinalOff", "=", "Offset", "+", "MV", ".", "getConstant", "(", ")", "+", "4", ";", "const", "MCExpr", "*", "Res", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_GOTPCREL", ",", "getContext", "(", ")", ")", ";", "const", "MCExpr", "*", "Off", "=", "MCConstantExpr", "::", "create", "(", "FinalOff", ",", "getContext", "(", ")", ")", ";", "return", "MCBinaryExpr", "::", "createAdd", "(", "Res", ",", "Off", ",", "getContext", "(", ")", ")", ";", "}", "</s>" ]

[ "Get", "the", "target", "specific", "PC", "relative", "GOT", "entry", "relocation", "." ]

[ "X86", "X86", "4" ]

[]

[ "<s>", "void", "HexagonTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "isHvxOperation", "(", "N", ",", "DAG", ")", ")", "{", "ReplaceHvxNodeResults", "(", "N", ",", "Results", ",", "DAG", ")", ";", "if", "(", "!", "Results", ".", "empty", "(", ")", ")", "return", ";", "}", "const", "SDLoc", "&", "dl", "(", "N", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SHL", ":", "return", ";", "case", "ISD", "::", "BITCAST", ":", "if", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i8", ")", "{", "if", "(", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "v8i1", ")", "{", "SDValue", "P", "=", "getInstr", "(", "Hexagon", "::", "C2_tfrpr", ",", "dl", ",", "MVT", "::", "i32", ",", "N", "->", "getOperand", "(", "0", ")", ",", "DAG", ")", ";", "SDValue", "T", "=", "DAG", ".", "getAnyExtOrTrunc", "(", "P", ",", "dl", ",", "MVT", "::", "i8", ")", ";", "Results", ".", "push_back", "(", "T", ")", ";", "}", "}", "break", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "ISD::SRL", "ISD::SRA", "ISD::SHL", "ISD::BITCAST", "0", "MVT::i8", "0", "MVT::v8i1", "Hexagon::C2_tfrpr", "MVT::i32", "0", "MVT::i8" ]

[]

[ "<s>", "SDValue", "BlackfinTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AllocateStack", "(", "12", ",", "4", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_Blackfin", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "TargetRegisterClass", "*", "RC", "=", "VA", ".", "getLocReg", "(", ")", "==", "BF", "::", "P0", "?", "BF", "::", "PRegisterClass", ":", "BF", "::", "DRegisterClass", ";", "assert", "(", "RC", "->", "contains", "(", "VA", ".", "getLocReg", "(", ")", ")", "&&", "\"Unexpected regclass in CCState\"", ")", ";", "assert", "(", "RC", "->", "hasType", "(", "RegVT", ")", "&&", "\"Unexpected regclass in CCState\"", ")", ";", "unsigned", "Reg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "Reg", ")", ";", "SDValue", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "RegVT", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "dl", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "ArgValue", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "}", "else", "{", "assert", "(", "VA", ".", "isMemLoc", "(", ")", "&&", "\"CCValAssign must be RegLoc or MemLoc\"", ")", ";", "unsigned", "ObjSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getStoreSize", "(", ")", ";", "int", "FI", "=", "MFI", "->", "CreateFixedObject", "(", "ObjSize", ",", "VA", ".", "getLocMemOffset", "(", ")", ",", "true", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "InVals", ".", "push_back", "(", "DAG", ".", "getLoad", "(", "VA", ".", "getValVT", "(", ")", ",", "dl", ",", "Chain", ",", "FIN", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "0", ")", ")", ";", "}", "}", "return", "Chain", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "Blackfin", "ISD::InputArg", "16", "12", "4", "0", "BF::P0", "BF::PRegisterClass", "BF::DRegisterClass", "\"Unexpected regclass in CCState\"", "\"Unexpected regclass in CCState\"", "ISD::AssertSext", "ISD::AssertZext", "ISD::TRUNCATE", "\"CCValAssign must be RegLoc or MemLoc\"", "MVT::i32", "0" ]

[]

[ "<s>", "static", "bool", "bfin_function_ok_for_sibcall", "(", "tree", "decl", "ATTRIBUTE_UNUSED", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "cgraph_node", "*", "this_func", ",", "*", "called_func", ";", "e_funkind", "fkind", "=", "funkind", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ";", "if", "(", "fkind", "!=", "SUBROUTINE", ")", "return", "false", ";", "if", "(", "!", "TARGET_ID_SHARED_LIBRARY", "||", "TARGET_SEP_DATA", ")", "return", "true", ";", "if", "(", "!", "decl", ")", "return", "false", ";", "this_func", "=", "cgraph_node", "::", "local_info_node", "(", "current_function_decl", ")", ";", "called_func", "=", "cgraph_node", "::", "local_info_node", "(", "decl", ")", ";", "if", "(", "!", "called_func", ")", "return", "false", ";", "return", "!", "called_func", "->", "local", "||", "this_func", "->", "local", ";", "}", "</s>" ]

[ "Decide", "whether", "we", "can", "make", "a", "sibling", "call", "to", "a", "function", ".", "DECL", "is", "the", "declaration", "of", "the", "function", "being", "targeted", "by", "the", "call", "and", "EXP", "is", "the", "CALL_EXPR", "representing", "the", "call", "." ]

[ "bfin" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "MachineInstr", "*", "MIa", ",", "MachineInstr", "*", "MIb", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "assert", "(", "MIa", "&&", "(", "MIa", "->", "mayLoad", "(", ")", "||", "MIa", "->", "mayStore", "(", ")", ")", "&&", "\"MIa must load from or modify a memory location\"", ")", ";", "assert", "(", "MIb", "&&", "(", "MIb", "->", "mayLoad", "(", ")", "||", "MIb", "->", "mayStore", "(", ")", ")", "&&", "\"MIb must load from or modify a memory location\"", ")", ";", "if", "(", "MIa", "->", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", "->", "hasUnmodeledSideEffects", "(", ")", ")", "return", "false", ";", "if", "(", "MIa", "->", "hasOrderedMemoryRef", "(", ")", "||", "MIb", "->", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "isDS", "(", "*", "MIa", ")", ")", "{", "if", "(", "isDS", "(", "*", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "!", "isFLAT", "(", "*", "MIb", ")", ";", "}", "if", "(", "isMUBUF", "(", "*", "MIa", ")", "||", "isMTBUF", "(", "*", "MIa", ")", ")", "{", "if", "(", "isMUBUF", "(", "*", "MIb", ")", "||", "isMTBUF", "(", "*", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "!", "isFLAT", "(", "*", "MIb", ")", "&&", "!", "isSMRD", "(", "*", "MIb", ")", ";", "}", "if", "(", "isSMRD", "(", "*", "MIa", ")", ")", "{", "if", "(", "isSMRD", "(", "*", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "!", "isFLAT", "(", "*", "MIb", ")", "&&", "!", "isMUBUF", "(", "*", "MIa", ")", "&&", "!", "isMTBUF", "(", "*", "MIa", ")", ";", "}", "if", "(", "isFLAT", "(", "*", "MIa", ")", ")", "{", "if", "(", "isFLAT", "(", "*", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "\"MIa must load from or modify a memory location\"", "\"MIb must load from or modify a memory location\"" ]

[]

[ "<s>", "static", "rtx", "push", "(", "int", "rn", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "word_mode", ",", "rn", ")", ";", "rtx", "x", ";", "if", "(", "!", "TARGET_NORMAL_MODE", ")", "x", "=", "gen_push_h8300hs_advanced", "(", "reg", ")", ";", "else", "x", "=", "gen_push_h8300hs_normal", "(", "reg", ")", ";", "x", "=", "F", "(", "emit_insn", "(", "x", ")", ",", "0", ")", ";", "add_reg_note", "(", "x", ",", "REG_INC", ",", "stack_pointer_rtx", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "Output", "RTL", "to", "push", "register", "RN", "onto", "the", "stack", "." ]

[ "h8300", "0" ]

[]

[ "<s>", "static", "rtx", "sparc_function_value_1", "(", "const_tree", "type", ",", "machine_mode", "mode", ",", "bool", "outgoing", ")", "{", "int", "regbase", "=", "(", "outgoing", "?", "SPARC_INCOMING_INT_ARG_FIRST", ":", "SPARC_OUTGOING_INT_ARG_FIRST", ")", ";", "enum", "mode_class", "mclass", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "int", "regno", ";", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "(", "TARGET_ARCH32", "&&", "size", "<=", "8", ")", "||", "(", "TARGET_ARCH64", "&&", "size", "<=", "32", ")", ")", ";", "if", "(", "mode", "==", "BLKmode", ")", "return", "function_arg_vector_value", "(", "size", ",", "SPARC_FP_ARG_FIRST", ")", ";", "mclass", "=", "MODE_FLOAT", ";", "}", "if", "(", "TARGET_ARCH64", "&&", "type", ")", "{", "if", "(", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "32", ")", ";", "return", "function_arg_record_value", "(", "type", ",", "mode", ",", "0", ",", "1", ",", "regbase", ")", ";", "}", "else", "if", "(", "TREE_CODE", "(", "type", ")", "==", "UNION_TYPE", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "32", ")", ";", "return", "function_arg_union_value", "(", "size", ",", "mode", ",", "0", ",", "regbase", ")", ";", "}", "else", "if", "(", "mclass", "==", "MODE_FLOAT", "||", "mclass", "==", "MODE_COMPLEX_FLOAT", ")", ";", "else", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "32", ")", ";", "mode", "=", "mode_for_size", "(", "size", "*", "BITS_PER_UNIT", ",", "MODE_INT", ",", "0", ")", ";", "if", "(", "mode", "==", "BLKmode", ")", "return", "function_arg_union_value", "(", "size", ",", "mode", ",", "0", ",", "regbase", ")", ";", "else", "mclass", "=", "MODE_INT", ";", "}", "else", "if", "(", "mclass", "==", "MODE_INT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<", "UNITS_PER_WORD", ")", "mode", "=", "word_mode", ";", "}", "else", "if", "(", "TARGET_ARCH32", "&&", "!", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "&&", "mclass", "==", "MODE_INT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<", "UNITS_PER_WORD", ")", "mode", "=", "word_mode", ";", "if", "(", "(", "mclass", "==", "MODE_FLOAT", "||", "mclass", "==", "MODE_COMPLEX_FLOAT", ")", "&&", "TARGET_FPU", ")", "regno", "=", "SPARC_FP_ARG_FIRST", ";", "else", "regno", "=", "regbase", ";", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Handle", "TARGET_FUNCTION_VALUE", ",", "and", "TARGET_LIBCALL_VALUE", "target", "hook", ".", "For", "v9", ",", "function", "return", "values", "are", "subject", "to", "the", "same", "rules", "as", "arguments", ",", "except", "that", "up", "to", "32", "bytes", "may", "be", "returned", "in", "registers", "." ]

[ "sparc", "8", "32", "32", "0", "1", "32", "0", "32", "0", "0" ]

[]

[ "<s>", "void", "WebAssemblyFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "auto", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "assert", "(", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "empty", "(", ")", "&&", "\"WebAssembly should not have callee-saved registers\"", ")", ";", "if", "(", "!", "needsSP", "(", "MF", ",", "MFI", ")", ")", "return", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "InsertPt", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "const", "TargetRegisterClass", "*", "PtrRC", "=", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getPointerRegClass", "(", "MF", ")", ";", "unsigned", "Zero", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "unsigned", "SPReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "const", "char", "*", "ES", "=", "\"__stack_pointer\"", ";", "auto", "*", "SPSymbol", "=", "MF", ".", "createExternalSymbolName", "(", "ES", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "Zero", ")", ".", "addImm", "(", "0", ")", ";", "auto", "*", "LoadMMO", "=", "new", "MachineMemOperand", "(", "MachinePointerInfo", "(", "MF", ".", "getPSVManager", "(", ")", ".", "getExternalSymbolCallEntry", "(", "ES", ")", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "4", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "LOAD_I32", ")", ",", "StackSize", "?", "SPReg", ":", "(", "unsigned", ")", "WebAssembly", "::", "SP32", ")", ".", "addExternalSymbol", "(", "SPSymbol", ")", ".", "addReg", "(", "Zero", ")", ".", "addImm", "(", "2", ")", ".", "addMemOperand", "(", "LoadMMO", ")", ";", "if", "(", "StackSize", ")", "{", "unsigned", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "StackSize", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "SUB_I32", ")", ",", "WebAssembly", "::", "SP32", ")", ".", "addReg", "(", "SPReg", ")", ".", "addReg", "(", "OffsetReg", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "COPY", ")", ",", "WebAssembly", "::", "FP32", ")", ".", "addReg", "(", "WebAssembly", "::", "SP32", ")", ";", "}", "if", "(", "StackSize", "&&", "needsSPWriteback", "(", "MF", ",", "MFI", ")", ")", "{", "writeSPToMemory", "(", "WebAssembly", "::", "SP32", ",", "MF", ",", "MBB", ",", "InsertPt", ",", "InsertPt", ",", "DL", ")", ";", "}", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "WebAssembly", "WebAssembly", "\"WebAssembly should not have callee-saved registers\"", "WebAssembly", "\"__stack_pointer\"", "WebAssembly::CONST_I32", "0", "4", "4", "WebAssembly::LOAD_I32", "WebAssembly::SP32", "2", "WebAssembly::CONST_I32", "WebAssembly::SUB_I32", "WebAssembly::SP32", "WebAssembly::COPY", "WebAssembly::FP32", "WebAssembly::SP32", "WebAssembly::SP32" ]

[]

[ "<s>", "bool", "SILowerControlFlow", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "LIS", "=", "getAnalysisIfAvailable", "<", "LiveIntervals", ">", "(", ")", ";", "MachineFunction", "::", "iterator", "NextBB", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "BI", "=", "NextBB", ")", "{", "NextBB", "=", "std", "::", "next", "(", "BI", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_IF", ":", "emitIf", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE", ":", "emitElse", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_BREAK", ":", "emitBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_IF_BREAK", ":", "emitIfBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE_BREAK", ":", "emitElseBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_LOOP", ":", "emitLoop", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_END_CF", ":", "emitEndCf", "(", "MI", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::SI_IF", "AMDGPU::SI_ELSE", "AMDGPU::SI_BREAK", "AMDGPU::SI_IF_BREAK", "AMDGPU::SI_ELSE_BREAK", "AMDGPU::SI_LOOP", "AMDGPU::SI_END_CF" ]

[]

[ "<s>", "void", "ARMBaseRegisterInfo", "::", "emitLoadConstPool", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "DebugLoc", "dl", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "int", "Val", ",", "ARMCC", "::", "CondCodes", "Pred", ",", "unsigned", "PredReg", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineConstantPool", "*", "ConstantPool", "=", "MF", ".", "getConstantPool", "(", ")", ";", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "Val", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "LDRcp", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ",", "SubIdx", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addReg", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "Pred", ")", ".", "addReg", "(", "PredReg", ")", ";", "}", "</s>" ]

[ "emitLoadConstPool", "-", "Emits", "a", "load", "from", "constpool", "to", "materialize", "the", "specified", "immediate", "." ]

[ "ARM", "ARM", "ARMCC::CondCodes", "4", "ARM::LDRcp", "0", "0" ]

[]

[ "<s>", "static", "void", "do_add3", "(", "rtx", "dest", ",", "rtx", "src1", ",", "rtx", "src2", ")", "{", "if", "(", "GET_MODE", "(", "dest", ")", "==", "DImode", ")", "emit_insn", "(", "gen_adddi3", "(", "dest", ",", "src1", ",", "src2", ")", ")", ";", "else", "emit_insn", "(", "gen_addsi3", "(", "dest", ",", "src1", ",", "src2", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "add", "of", "the", "proper", "mode", "for", "DEST", ".", "DEST", "is", "the", "destination", "register", "for", "the", "add", ".", "SRC1", "is", "the", "first", "add", "input", ".", "SRC2", "is", "the", "second", "add", "input", ".", "Computes", "DEST", "=", "SRC1+SRC2", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "WebAssemblyTargetAsmStreamer", "::", "emitFunctionType", "(", "const", "MCSymbolWasm", "*", "Sym", ")", "{", "assert", "(", "Sym", "->", "isFunction", "(", ")", ")", ";", "OS", "<<", "\"\\t.functype\\t\"", "<<", "Sym", "->", "getName", "(", ")", "<<", "\" \"", ";", "OS", "<<", "WebAssembly", "::", "signatureToString", "(", "Sym", "->", "getSignature", "(", ")", ")", ";", "OS", "<<", "\"\\n\"", ";", "}", "</s>" ]

[ ".functype" ]

[ "WebAssembly", "WebAssembly", "\"\\t.functype\\t\"", "\" \"", "WebAssembly::signatureToString", "\"\\n\"" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAdvSIMDScalar", ")", "{", "addPass", "(", "createAArch64AdvSIMDScalar", "(", ")", ")", ";", "addPass", "(", "&", "PeepholeOptimizerID", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

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

[]

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

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

[ "R600" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "hasPairedLoad", "(", "EVT", "LoadedType", ",", "unsigned", "&", "RequiredAligment", ")", "const", "{", "if", "(", "!", "LoadedType", ".", "isSimple", "(", ")", "||", "(", "!", "LoadedType", ".", "isInteger", "(", ")", "&&", "!", "LoadedType", ".", "isFloatingPoint", "(", ")", ")", ")", "return", "false", ";", "RequiredAligment", "=", "0", ";", "unsigned", "NumBits", "=", "LoadedType", ".", "getSizeInBits", "(", ")", ";", "return", "NumBits", "==", "32", "||", "NumBits", "==", "64", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supplies", "and", "combines", "to", "a", "paired", "load", "two", "loaded", "values", "of", "type", "LoadedType", "next", "to", "each", "other", "in", "memory", "." ]

[ "AArch64", "AArch64", "0", "32", "64" ]

[]

[ "<s>", "bool", "MINA32AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".ent\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".end\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".frame\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".set\"", ")", "{", "return", "parseDirectiveSet", "(", ")", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".fmask\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".mask\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".gpword\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "MINA32", "MINA32", "\".ent\"", "\".end\"", "\".frame\"", "\".set\"", "\".fmask\"", "\".mask\"", "\".gpword\"" ]

[]

[ "<s>", "AArch64Subtarget", "::", "AArch64Subtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ",", "bool", "LittleEndian", ")", ":", "AArch64GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "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>", "bool", "LanaiAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "StringRef", "Mnemonic", "=", "splitMnemonic", "(", "Name", ",", "NameLoc", ",", "&", "Operands", ")", ";", "if", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "parseOperand", "(", "&", "Operands", ",", "Mnemonic", ")", "!=", "MatchOperand_Success", ")", "return", "true", ";", "if", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "Name", "==", "\"st\"", "&&", "Operands", ".", "size", "(", ")", "==", "2", ")", "{", "Operands", ".", "erase", "(", "Operands", ".", "begin", "(", ")", ",", "Operands", ".", "begin", "(", ")", "+", "1", ")", ";", "Operands", ".", "insert", "(", "Operands", ".", "begin", "(", ")", ",", "LanaiOperand", "::", "CreateToken", "(", "\"s\"", ",", "NameLoc", ")", ")", ";", "Operands", ".", "insert", "(", "Operands", ".", "begin", "(", ")", "+", "1", ",", "LanaiOperand", "::", "createImm", "(", "MCConstantExpr", "::", "create", "(", "LPCC", "::", "ICC_T", ",", "getContext", "(", ")", ")", ",", "NameLoc", ",", "NameLoc", ")", ")", ";", "}", "if", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "Name", ".", "startswith", "(", "\"bt\"", ")", "&&", "Operands", ".", "size", "(", ")", "==", "3", ")", "{", "Operands", ".", "erase", "(", "Operands", ".", "begin", "(", ")", ",", "Operands", ".", "begin", "(", ")", "+", "2", ")", ";", "Operands", ".", "insert", "(", "Operands", ".", "begin", "(", ")", ",", "LanaiOperand", "::", "CreateToken", "(", "\"bt\"", ",", "NameLoc", ")", ")", ";", "}", "while", "(", "Lexer", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "Lexer", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "&", "Operands", ",", "Mnemonic", ")", "!=", "MatchOperand_Success", ")", "return", "true", ";", "}", "if", "(", "IsMemoryAssignmentError", "(", "Operands", ")", ")", "{", "Error", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ",", "\"the destination register can't equal the base register in an \"", "\"instruction that modifies the base register.\"", ")", ";", "return", "true", ";", "}", "if", "(", "MaybePredicatedInst", "(", "Operands", ")", ")", "{", "Operands", ".", "insert", "(", "Operands", ".", "begin", "(", ")", "+", "1", ",", "LanaiOperand", "::", "createImm", "(", "MCConstantExpr", "::", "create", "(", "LPCC", "::", "ICC_T", ",", "getContext", "(", ")", ")", ",", "NameLoc", ",", "NameLoc", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "Lanai", "Lanai", "\"st\"", "2", "1", "LanaiOperand::CreateToken", "\"s\"", "1", "LanaiOperand::createImm", "\"bt\"", "3", "2", "LanaiOperand::CreateToken", "\"bt\"", "\"the destination register can't equal the base register in an \"", "\"instruction that modifies the base register.\"", "1", "LanaiOperand::createImm" ]

[]

[ "<s>", "static", "bool", "arm_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "machine_mode", "mode", ";", "if", "(", "size", "==", "UNITS_PER_WORD", "&&", "aligned_p", ")", "{", "fputs", "(", "\"\\t.word\\t\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "if", "(", "NEED_GOT_RELOC", "&&", "flag_pic", "&&", "making_const_table", "&&", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", ")", "{", "if", "(", "!", "arm_pic_data_is_text_relative", "||", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "(", "!", "SYMBOL_REF_LOCAL_P", "(", "x", ")", "||", "(", "SYMBOL_REF_DECL", "(", "x", ")", "?", "DECL_WEAK", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", ":", "0", ")", ")", ")", ")", "fputs", "(", "\"(GOT)\"", ",", "asm_out_file", ")", ";", "else", "fputs", "(", "\"(GOTOFF)\"", ",", "asm_out_file", ")", ";", "}", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "arm_vector_mode_supported_p", "(", "mode", ")", ")", "{", "int", "i", ",", "units", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", ";", "units", "=", "CONST_VECTOR_NUNITS", "(", "x", ")", ";", "size", "=", "GET_MODE_UNIT_SIZE", "(", "mode", ")", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", ")", "for", "(", "i", "=", "0", ";", "i", "<", "units", ";", "i", "++", ")", "{", "rtx", "elt", "=", "CONST_VECTOR_ELT", "(", "x", ",", "i", ")", ";", "assemble_integer", "(", "elt", ",", "size", ",", "i", "==", "0", "?", "BIGGEST_ALIGNMENT", ":", "size", "*", "BITS_PER_UNIT", ",", "1", ")", ";", "}", "else", "for", "(", "i", "=", "0", ";", "i", "<", "units", ";", "i", "++", ")", "{", "rtx", "elt", "=", "CONST_VECTOR_ELT", "(", "x", ",", "i", ")", ";", "assemble_real", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "elt", ")", ",", "GET_MODE_INNER", "(", "mode", ")", ",", "i", "==", "0", "?", "BIGGEST_ALIGNMENT", ":", "size", "*", "BITS_PER_UNIT", ")", ";", "}", "return", "true", ";", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "assembling", "integer", "objects", ".", "The", "ARM", "version", "needs", "to", "handle", "word-sized", "values", "specially", "." ]

[ "arm", "\"\\t.word\\t\"", "0", "\"(GOT)\"", "\"(GOTOFF)\"", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "CCAssignFn", "*", "ARMFastISel", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "Return", ",", "bool", "isVarArg", ")", "{", "switch", "(", "CC", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "if", "(", "Subtarget", "->", "hasVFP2", "(", ")", "&&", "!", "isVarArg", ")", "{", "if", "(", "!", "Subtarget", "->", "isAAPCS_ABI", "(", ")", ")", "return", "(", "Return", "?", "RetFastCC_ARM_APCS", ":", "FastCC_ARM_APCS", ")", ";", "return", "(", "Return", "?", "RetCC_ARM_AAPCS_VFP", ":", "CC_ARM_AAPCS_VFP", ")", ";", "}", "LLVM_FALLTHROUGH", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "if", "(", "Subtarget", "->", "isAAPCS_ABI", "(", ")", ")", "{", "if", "(", "Subtarget", "->", "hasVFP2", "(", ")", "&&", "TM", ".", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Hard", "&&", "!", "isVarArg", ")", "return", "(", "Return", "?", "RetCC_ARM_AAPCS_VFP", ":", "CC_ARM_AAPCS_VFP", ")", ";", "else", "return", "(", "Return", "?", "RetCC_ARM_AAPCS", ":", "CC_ARM_AAPCS", ")", ";", "}", "else", "{", "return", "(", "Return", "?", "RetCC_ARM_APCS", ":", "CC_ARM_APCS", ")", ";", "}", "case", "CallingConv", "::", "ARM_AAPCS_VFP", ":", "case", "CallingConv", "::", "Swift", ":", "if", "(", "!", "isVarArg", ")", "return", "(", "Return", "?", "RetCC_ARM_AAPCS_VFP", ":", "CC_ARM_AAPCS_VFP", ")", ";", "LLVM_FALLTHROUGH", ";", "case", "CallingConv", "::", "ARM_AAPCS", ":", "return", "(", "Return", "?", "RetCC_ARM_AAPCS", ":", "CC_ARM_AAPCS", ")", ";", "case", "CallingConv", "::", "ARM_APCS", ":", "return", "(", "Return", "?", "RetCC_ARM_APCS", ":", "CC_ARM_APCS", ")", ";", "case", "CallingConv", "::", "GHC", ":", "if", "(", "Return", ")", "llvm_unreachable", "(", "\"Can't return in GHC call convention\"", ")", ";", "else", "return", "CC_ARM_APCS_GHC", ";", "}", "}", "</s>" ]

[ "Selects", "the", "correct", "CCAssignFn", "for", "a", "given", "CallingConvention", "value", "." ]

[ "ARM", "ARM", "\"Unsupported calling convention\"", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "\"Can't return in GHC call convention\"", "ARM" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "GlobalsEmitted", ")", "{", "emitGlobals", "(", "M", ")", ";", "GlobalsEmitted", "=", "true", ";", "}", "Module", "::", "GlobalListType", "&", "global_list", "=", "M", ".", "getGlobalList", "(", ")", ";", "int", "i", ",", "n", "=", "global_list", ".", "size", "(", ")", ";", "GlobalVariable", "*", "*", "gv_array", "=", "new", "GlobalVariable", "*", "[", "n", "]", ";", "i", "=", "0", ";", "for", "(", "Module", "::", "global_iterator", "I", "=", "global_list", ".", "begin", "(", ")", ",", "E", "=", "global_list", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "gv_array", "[", "i", "++", "]", "=", "&", "*", "I", ";", "while", "(", "!", "global_list", ".", "empty", "(", ")", ")", "global_list", ".", "remove", "(", "global_list", ".", "begin", "(", ")", ")", ";", "bool", "ret", "=", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "global_list", ".", "insert", "(", "global_list", ".", "end", "(", ")", ",", "gv_array", "[", "i", "]", ")", ";", "clearAnnotationCache", "(", "&", "M", ")", ";", "delete", "[", "]", "gv_array", ";", "return", "ret", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "NVPTX", "NVPTX", "0", "0" ]

[]

[ "<s>", "void", "HexagonCommonGEP", "::", "collect", "(", ")", "{", "ValueVect", "BO", ";", "getBlockTraversalOrder", "(", "&", "Fn", "->", "front", "(", ")", ",", "BO", ")", ";", "ValueToNodeMap", "NM", ";", "for", "(", "ValueVect", "::", "iterator", "I", "=", "BO", ".", "begin", "(", ")", ",", "E", "=", "BO", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "BasicBlock", "*", "B", "=", "cast", "<", "BasicBlock", ">", "(", "*", "I", ")", ";", "for", "(", "BasicBlock", "::", "iterator", "J", "=", "B", "->", "begin", "(", ")", ",", "F", "=", "B", "->", "end", "(", ")", ";", "J", "!=", "F", ";", "++", "J", ")", "{", "if", "(", "!", "isa", "<", "GetElementPtrInst", ">", "(", "J", ")", ")", "continue", ";", "GetElementPtrInst", "*", "GepI", "=", "cast", "<", "GetElementPtrInst", ">", "(", "J", ")", ";", "if", "(", "isHandledGepForm", "(", "GepI", ")", ")", "processGepInst", "(", "GepI", ",", "NM", ")", ";", "}", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Gep nodes after initial collection:\\n\"", "<<", "Nodes", ")", ";", "}", "</s>" ]

[ "Analyze", "the", "given", "instruction", "MI", "and", "fill", "in", "the", "Uses", ",", "Defs", "and", "DeadDefs", "list", "based", "on", "the", "MachineOperand", "flags", "." ]

[ "Hexagon", "Hexagon", "\"Gep nodes after initial collection:\\n\"" ]

[]

[ "<s>", "bool", "OR1KAsmPrinter", "::", "isBlockOnlyReachableByFallthrough", "(", "const", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "const", "MachineBasicBlock", "*", "Pred", "=", "*", "MBB", "->", "pred_begin", "(", ")", ";", "if", "(", "const", "BasicBlock", "*", "bb", "=", "Pred", "->", "getBasicBlock", "(", ")", ")", "if", "(", "isa", "<", "SwitchInst", ">", "(", "bb", "->", "getTerminator", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "AsmPrinter", "::", "isBlockOnlyReachableByFallthrough", "(", "MBB", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "const_iterator", "I", "=", "Pred", "->", "end", "(", ")", ";", "while", "(", "I", "!=", "Pred", "->", "begin", "(", ")", "&&", "!", "(", "--", "I", ")", "->", "isTerminator", "(", ")", ")", ";", "return", "!", "I", "->", "isBarrier", "(", ")", ";", "}", "</s>" ]

[ "isBlockOnlyReachableByFallthough", "-", "Return", "true", "if", "the", "basic", "block", "has", "exactly", "one", "predecessor", "and", "the", "control", "transfer", "mechanism", "between", "the", "predecessor", "and", "this", "block", "is", "a", "fall-through", "." ]

[ "OR1K", "OR1K" ]

[]

[ "<s>", "const", "TargetRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "getSubtargetImpl", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "XCore" ]

[]

[ "<s>", "BitVector", "SparcRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "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", ")", ";", "if", "(", "!", "Subtarget", ".", "isV9", "(", ")", ")", "{", "for", "(", "unsigned", "n", "=", "0", ";", "n", "!=", "16", ";", "++", "n", ")", "{", "for", "(", "MCRegAliasIterator", "AI", "(", "SP", "::", "D16", "+", "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", "." ]

[ "Sparc", "Sparc", "SP::G1", "SP::G2", "SP::G3", "SP::G4", "SP::G5", "SP::O6", "SP::I6", "SP::I7", "SP::G0", "SP::G6", "SP::G7", "0", "16", "SP::D16" ]

[]

[ "<s>", "bool", "AVRFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "unsigned", "CalleeFrameSize", "=", "0", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "AVRMachineFunctionInfo", "*", "AVRFI", "=", "MF", ".", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "I", ":", "llvm", "::", "reverse", "(", "CSI", ")", ")", "{", "Register", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "bool", "IsNotLiveIn", "=", "!", "MBB", ".", "isLiveIn", "(", "Reg", ")", ";", "assert", "(", "TRI", "->", "getRegSizeInBits", "(", "*", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ")", "==", "8", "&&", "\"Invalid register size\"", ")", ";", "if", "(", "IsNotLiveIn", ")", "{", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "PUSHRr", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "IsNotLiveIn", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "++", "CalleeFrameSize", ";", "}", "AVRFI", "->", "setCalleeSavedFrameSize", "(", "CalleeFrameSize", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "0", "AVR", "AVR", "AVR", "AVR", "AVR", "8", "\"Invalid register size\"", "AVR::PUSHRr", "AVR" ]

[]

[ "<s>", "static", "void", "v850_insert_attributes", "(", "tree", "decl", ",", "tree", "*", "attr_ptr", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "data_area_stack", "&&", "data_area_stack", "->", "data_area", "&&", "current_function_decl", "==", "NULL_TREE", "&&", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "||", "TREE_CODE", "(", "decl", ")", "==", "CONST_DECL", ")", "&&", "v850_get_data_area", "(", "decl", ")", "==", "DATA_AREA_NORMAL", ")", "v850_set_data_area", "(", "decl", ",", "data_area_stack", "->", "data_area", ")", ";", "if", "(", "GHS_default_section_names", "[", "(", "int", ")", "GHS_SECTION_KIND_SDATA", "]", "==", "NULL", ")", "{", "GHS_default_section_names", "[", "(", "int", ")", "GHS_SECTION_KIND_SDATA", "]", "=", "\".sdata\"", ";", "GHS_default_section_names", "[", "(", "int", ")", "GHS_SECTION_KIND_ROSDATA", "]", "=", "\".rosdata\"", ";", "GHS_default_section_names", "[", "(", "int", ")", "GHS_SECTION_KIND_TDATA", "]", "=", "\".tdata\"", ";", "GHS_default_section_names", "[", "(", "int", ")", "GHS_SECTION_KIND_ZDATA", "]", "=", "\".zdata\"", ";", "GHS_default_section_names", "[", "(", "int", ")", "GHS_SECTION_KIND_ROZDATA", "]", "=", "\".rozdata\"", ";", "}", "if", "(", "current_function_decl", "==", "NULL_TREE", "&&", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "||", "TREE_CODE", "(", "decl", ")", "==", "CONST_DECL", "||", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "&&", "(", "!", "DECL_EXTERNAL", "(", "decl", ")", "||", "DECL_INITIAL", "(", "decl", ")", ")", "&&", "!", "DECL_SECTION_NAME", "(", "decl", ")", ")", "{", "enum", "GHS_section_kind", "kind", "=", "GHS_SECTION_KIND_DEFAULT", ";", "const", "char", "*", "chosen_section", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "kind", "=", "GHS_SECTION_KIND_TEXT", ";", "else", "{", "switch", "(", "v850_get_data_area", "(", "decl", ")", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "DATA_AREA_SDA", ":", "kind", "=", "(", "(", "TREE_READONLY", "(", "decl", ")", ")", "?", "GHS_SECTION_KIND_ROSDATA", ":", "GHS_SECTION_KIND_SDATA", ")", ";", "break", ";", "case", "DATA_AREA_TDA", ":", "kind", "=", "GHS_SECTION_KIND_TDATA", ";", "break", ";", "case", "DATA_AREA_ZDA", ":", "kind", "=", "(", "(", "TREE_READONLY", "(", "decl", ")", ")", "?", "GHS_SECTION_KIND_ROZDATA", ":", "GHS_SECTION_KIND_ZDATA", ")", ";", "break", ";", "case", "DATA_AREA_NORMAL", ":", "if", "(", "TREE_READONLY", "(", "decl", ")", ")", "kind", "=", "GHS_SECTION_KIND_RODATA", ";", "else", "if", "(", "DECL_INITIAL", "(", "decl", ")", ")", "kind", "=", "GHS_SECTION_KIND_DATA", ";", "else", "kind", "=", "GHS_SECTION_KIND_BSS", ";", "}", "}", "chosen_section", "=", "GHS_current_section_names", "[", "(", "int", ")", "kind", "]", ";", "if", "(", "chosen_section", "==", "NULL", ")", "chosen_section", "=", "GHS_default_section_names", "[", "(", "int", ")", "kind", "]", ";", "if", "(", "chosen_section", ")", "{", "set_decl_section_name", "(", "decl", ",", "chosen_section", ")", ";", "}", "}", "}", "</s>" ]

[ "Add", "data", "area", "to", "the", "given", "declaration", "if", "a", "ghs", "data", "area", "pragma", "is", "currently", "in", "effect", "(", "#", "pragma", "ghs", "startXXX/endXXX", ")", "." ]

[ "v850", "\".sdata\"", "\".rosdata\"", "\".tdata\"", "\".zdata\"", "\".rozdata\"" ]

[]

[ "<s>", "static", "bool", "expand_perm_with_rot", "(", "const", "struct", "expand_vec_perm_d", "&", "d", ")", "{", "if", "(", "d", ".", "nelt", "!=", "4", ")", "return", "false", ";", "if", "(", "d", ".", "op0", "==", "d", ".", "op1", "&&", "is_reverse_perm_mask", "(", "d", ")", ")", "{", "if", "(", "d", ".", "testing_p", ")", "return", "true", ";", "rtx", "tmp", "=", "gen_reg_rtx", "(", "d", ".", "vmode", ")", ";", "rtx", "op0_reg", "=", "force_reg", "(", "GET_MODE", "(", "d", ".", "op0", ")", ",", "d", ".", "op0", ")", ";", "emit_insn", "(", "gen_vpdi4_2", "(", "d", ".", "vmode", ",", "tmp", ",", "op0_reg", ",", "op0_reg", ")", ")", ";", "if", "(", "d", ".", "vmode", "==", "V4SImode", ")", "emit_insn", "(", "gen_rotlv4si3_di", "(", "d", ".", "target", ",", "tmp", ")", ")", ";", "else", "if", "(", "d", ".", "vmode", "==", "V4SFmode", ")", "emit_insn", "(", "gen_rotlv4sf3_di", "(", "d", ".", "target", ",", "tmp", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "The", "case", "of", "reversing", "a", "four-element", "vector", "[", "0", ",", "1", ",", "2", ",", "3", "]", "can", "be", "handled", "by", "first", "permuting", "the", "doublewords", "[", "2", ",", "3", ",", "0", ",", "1", "]", "and", "subsequently", "rotating", "them", "by", "32", "bits", "." ]

[ "s390", "4" ]

[]

[ "<s>", "void", "AMDGPUAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ")", "const", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "&", "Asm", ".", "getContext", "(", ")", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "uint32_t", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "static_cast", "<", "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", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

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

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

[ "Sparc", "Sparc", "Sparc", "SparcOperand::RegisterKind" ]

[]

[ "<s>", "static", "bool", "loongarch_valid_offset_p", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "(", "const_arith_operand", "(", "x", ",", "Pmode", ")", "||", "(", "(", "mode", "==", "E_SImode", "||", "mode", "==", "E_DImode", ")", "&&", "const_imm16_operand", "(", "x", ",", "Pmode", ")", "&&", "(", "loongarch_signed_immediate_p", "(", "INTVAL", "(", "x", ")", ",", "14", ",", "2", ")", ")", ")", ")", ")", "return", "false", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", "&&", "!", "IMM12_OPERAND", "(", "INTVAL", "(", "x", ")", "+", "GET_MODE_SIZE", "(", "mode", ")", "-", "UNITS_PER_WORD", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", ",", "for", "every", "base", "register", "BASE_REG", ",", "(", "plus", "BASE_REG", "X", ")", "can", "address", "a", "value", "of", "mode", "MODE", "." ]

[ "loongarch", "14", "2" ]

[]

[ "<s>", "static", "void", "nvptx_reorg_subreg", "(", "void", ")", "{", "struct", "reg_replace", "qiregs", ",", "hiregs", ",", "siregs", ",", "diregs", ";", "rtx_insn", "*", "insn", ",", "*", "next", ";", "qiregs", ".", "n_allocated", "=", "0", ";", "hiregs", ".", "n_allocated", "=", "0", ";", "siregs", ".", "n_allocated", "=", "0", ";", "diregs", ".", "n_allocated", "=", "0", ";", "qiregs", ".", "mode", "=", "QImode", ";", "hiregs", ".", "mode", "=", "HImode", ";", "siregs", ".", "mode", "=", "SImode", ";", "diregs", ".", "mode", "=", "DImode", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "next", ")", "{", "next", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "!", "NONDEBUG_INSN_P", "(", "insn", ")", "||", "asm_noperands", "(", "PATTERN", "(", "insn", ")", ")", ">=", "0", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", ")", "continue", ";", "qiregs", ".", "n_in_use", "=", "0", ";", "hiregs", ".", "n_in_use", "=", "0", ";", "siregs", ".", "n_in_use", "=", "0", ";", "diregs", ".", "n_in_use", "=", "0", ";", "extract_insn", "(", "insn", ")", ";", "enum", "attr_subregs_ok", "s_ok", "=", "get_attr_subregs_ok", "(", "insn", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "recog_data", ".", "n_operands", ";", "i", "++", ")", "{", "rtx", "op", "=", "recog_data", ".", "operand", "[", "i", "]", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "SUBREG", ")", "continue", ";", "rtx", "inner", "=", "SUBREG_REG", "(", "op", ")", ";", "machine_mode", "outer_mode", "=", "GET_MODE", "(", "op", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE", "(", "inner", ")", ";", "gcc_assert", "(", "s_ok", ")", ";", "if", "(", "s_ok", "&&", "(", "GET_MODE_PRECISION", "(", "inner_mode", ")", ">=", "GET_MODE_PRECISION", "(", "outer_mode", ")", ")", ")", "continue", ";", "gcc_assert", "(", "SCALAR_INT_MODE_P", "(", "outer_mode", ")", ")", ";", "struct", "reg_replace", "*", "r", "=", "(", "outer_mode", "==", "QImode", "?", "&", "qiregs", ":", "outer_mode", "==", "HImode", "?", "&", "hiregs", ":", "outer_mode", "==", "SImode", "?", "&", "siregs", ":", "&", "diregs", ")", ";", "rtx", "new_reg", "=", "get_replacement", "(", "r", ")", ";", "if", "(", "recog_data", ".", "operand_type", "[", "i", "]", "!=", "OP_OUT", ")", "{", "enum", "rtx_code", "code", ";", "if", "(", "GET_MODE_PRECISION", "(", "inner_mode", ")", "<", "GET_MODE_PRECISION", "(", "outer_mode", ")", ")", "code", "=", "ZERO_EXTEND", ";", "else", "code", "=", "TRUNCATE", ";", "rtx", "pat", "=", "gen_rtx_SET", "(", "new_reg", ",", "gen_rtx_fmt_e", "(", "code", ",", "outer_mode", ",", "inner", ")", ")", ";", "emit_insn_before", "(", "pat", ",", "insn", ")", ";", "}", "if", "(", "recog_data", ".", "operand_type", "[", "i", "]", "!=", "OP_IN", ")", "{", "enum", "rtx_code", "code", ";", "if", "(", "GET_MODE_PRECISION", "(", "inner_mode", ")", "<", "GET_MODE_PRECISION", "(", "outer_mode", ")", ")", "code", "=", "TRUNCATE", ";", "else", "code", "=", "ZERO_EXTEND", ";", "rtx", "pat", "=", "gen_rtx_SET", "(", "inner", ",", "gen_rtx_fmt_e", "(", "code", ",", "inner_mode", ",", "new_reg", ")", ")", ";", "emit_insn_after", "(", "pat", ",", "insn", ")", ";", "}", "validate_change", "(", "insn", ",", "recog_data", ".", "operand_loc", "[", "i", "]", ",", "new_reg", ",", "false", ")", ";", "}", "}", "}", "</s>" ]

[ "Clean", "up", "subreg", "operands", ".", "In", "ptx", "assembly", ",", "everything", "is", "typed", ",", "and", "the", "presence", "of", "subregs", "would", "break", "the", "rules", "for", "most", "instructions", ".", "Replace", "them", "with", "a", "suitable", "new", "register", "of", "the", "right", "size", ",", "plus", "conversion", "copyin/copyout", "instructions", "." ]

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

[]

[ "<s>", "void", "ix86_emit_i387_asinh", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "e1", "=", "gen_reg_rtx", "(", "XFmode", ")", ";", "rtx", "e2", "=", "gen_reg_rtx", "(", "XFmode", ")", ";", "rtx", "scratch", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "rtx", "flags", "=", "gen_rtx_REG", "(", "CCNOmode", ",", "FLAGS_REG", ")", ";", "rtx", "cst1", ",", "tmp", ";", "rtx_code_label", "*", "jump_label", "=", "gen_label_rtx", "(", ")", ";", "rtx_insn", "*", "insn", ";", "emit_insn", "(", "gen_mulxf3", "(", "e1", ",", "op1", ",", "op1", ")", ")", ";", "cst1", "=", "force_reg", "(", "XFmode", ",", "CONST1_RTX", "(", "XFmode", ")", ")", ";", "emit_insn", "(", "gen_addxf3", "(", "e2", ",", "e1", ",", "cst1", ")", ")", ";", "emit_insn", "(", "gen_sqrtxf2", "(", "e2", ",", "e2", ")", ")", ";", "emit_insn", "(", "gen_addxf3", "(", "e2", ",", "e2", ",", "cst1", ")", ")", ";", "emit_insn", "(", "gen_divxf3", "(", "e1", ",", "e1", ",", "e2", ")", ")", ";", "emit_insn", "(", "gen_fxamxf2_i387", "(", "scratch", ",", "op1", ")", ")", ";", "emit_insn", "(", "gen_absxf2", "(", "e2", ",", "op1", ")", ")", ";", "emit_insn", "(", "gen_addxf3", "(", "e1", ",", "e1", ",", "e2", ")", ")", ";", "ix86_emit_i387_log1p", "(", "e2", ",", "e1", ")", ";", "emit_insn", "(", "gen_testqi_ext_1_ccno", "(", "scratch", ",", "GEN_INT", "(", "0x02", ")", ")", ")", ";", "tmp", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "gen_rtx_EQ", "(", "VOIDmode", ",", "flags", ",", "const0_rtx", ")", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "jump_label", ")", ",", "pc_rtx", ")", ";", "insn", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "tmp", ")", ")", ";", "predict_jump", "(", "REG_BR_PROB_BASE", "*", "50", "/", "100", ")", ";", "JUMP_LABEL", "(", "insn", ")", "=", "jump_label", ";", "emit_insn", "(", "gen_negxf2", "(", "e2", ",", "e2", ")", ")", ";", "emit_label", "(", "jump_label", ")", ";", "LABEL_NUSES", "(", "jump_label", ")", "=", "1", ";", "emit_move_insn", "(", "op0", ",", "e2", ")", ";", "}", "</s>" ]

[ "Output", "code", "to", "perform", "an", "asinh", "XFmode", "calculation", "." ]

[ "i386", "0x02", "50", "100", "1" ]

[]

[ "<s>", "unsigned", "MOSTargetLowering", "::", "getNumRegistersForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ",", "const", "ISD", "::", "ArgFlagsTy", "&", "Flags", ")", "const", "{", "if", "(", "Flags", ".", "isPointer", "(", ")", ")", "return", "1", ";", "return", "TargetLowering", "::", "getNumRegistersForCallingConv", "(", "Context", ",", "CC", ",", "VT", ",", "Flags", ")", ";", "}", "</s>" ]

[ "Certain", "targets", "require", "unusual", "breakdowns", "of", "certain", "types", "." ]

[ "MOS", "MOS", "ISD::ArgFlagsTy", "1" ]

[]

[ "<s>", "void", "SPIRVPassConfig", "::", "addIRPasses", "(", ")", "{", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "addPass", "(", "createSPIRVLowerConstExprLegacyPass", "(", ")", ")", ";", "addPass", "(", "createSPIRVOCLRegularizerPass", "(", ")", ")", ";", "addPass", "(", "createSPIRVPreTranslationLegalizerPass", "(", ")", ")", ";", "}", "</s>" ]

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

[ "SPIRV", "SPIRV", "SPIRV", "SPIRV", "SPIRV" ]

[]

[ "<s>", "bool", "MipsFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "DisableFramePointerElim", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "AAPTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_AAP", ")", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "AAP", "AAP", "ISD::OutputArg", "16", "AAP" ]

[]

[ "<s>", "static", "int", "rs6000_emit_p9_fp_cmove", "(", "rtx", "dest", ",", "rtx", "op", ",", "rtx", "true_cond", ",", "rtx", "false_cond", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "rtx", "op0", "=", "XEXP", "(", "op", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "op", ",", "1", ")", ";", "machine_mode", "result_mode", "=", "GET_MODE", "(", "dest", ")", ";", "rtx", "compare_rtx", ";", "rtx", "cmove_rtx", ";", "rtx", "clobber_rtx", ";", "if", "(", "!", "can_create_pseudo_p", "(", ")", ")", "return", "0", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "GE", ":", "case", "GT", ":", "break", ";", "case", "NE", ":", "case", "LT", ":", "case", "LE", ":", "code", "=", "swap_condition", "(", "code", ")", ";", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "break", ";", "default", ":", "return", "0", ";", "}", "compare_rtx", "=", "gen_rtx_fmt_ee", "(", "code", ",", "CCFPmode", ",", "op0", ",", "op1", ")", ";", "cmove_rtx", "=", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_IF_THEN_ELSE", "(", "result_mode", ",", "compare_rtx", ",", "true_cond", ",", "false_cond", ")", ")", ";", "clobber_rtx", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "V2DImode", ")", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "cmove_rtx", ",", "clobber_rtx", ")", ")", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "ISA", "3.0", "(", "power9", ")", "conditional", "move", "subcase", "to", "emit", "XSCMP", "{", "EQ", ",", "GE", ",", "GT", ",", "NE", "}", "DP", "and", "XXSEL", "instructions", "for", "SF/DF", "scalars", ".", "Move", "TRUE_COND", "to", "DEST", "if", "OP", "of", "the", "operands", "of", "the", "last", "comparison", "is", "nonzero/true", ",", "FALSE_COND", "if", "it", "is", "zero/false", ".", "Return", "0", "if", "the", "hardware", "has", "no", "such", "operation", "." ]

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

[]

[ "<s>", "void", "MipsMCInstLower", "::", "Initialize", "(", "Mangler", "*", "M", ",", "MCContext", "*", "C", ")", "{", "Mang", "=", "M", ";", "Ctx", "=", "C", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]