Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "bool", "ix86_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", ")", "{", "tree", "type", ",", "decl_or_type", ";", "rtx", "a", ",", "b", ";", "bool", "bind_global", "=", "decl", "&&", "!", "targetm", ".", "binds_local_p", "(", "decl", ")", ";", "if", "(", "!", "TARGET_MACHO", "&&", "!", "TARGET_64BIT", "&&", "flag_pic", "&&", "flag_plt", "&&", "bind_global", ")", "return", "false", ";", "if", "(", "ix86_minimum_incoming_stack_boundary", "(", "true", ")", "<", "PREFERRED_STACK_BOUNDARY", ")", "return", "false", ";", "if", "(", "decl", ")", "{", "decl_or_type", "=", "decl", ";", "type", "=", "TREE_TYPE", "(", "decl", ")", ";", "}", "else", "{", "type", "=", "CALL_EXPR_FN", "(", "exp", ")", ";", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "decl_or_type", "=", "type", ";", "}", "a", "=", "ix86_function_value", "(", "TREE_TYPE", "(", "exp", ")", ",", "decl_or_type", ",", "false", ")", ";", "b", "=", "ix86_function_value", "(", "TREE_TYPE", "(", "DECL_RESULT", "(", "cfun", "->", "decl", ")", ")", ",", "cfun", "->", "decl", ",", "false", ")", ";", "if", "(", "STACK_REG_P", "(", "a", ")", "||", "STACK_REG_P", "(", "b", ")", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "a", ",", "b", ")", ")", "return", "false", ";", "}", "else", "if", "(", "VOID_TYPE_P", "(", "TREE_TYPE", "(", "DECL_RESULT", "(", "cfun", "->", "decl", ")", ")", ")", ")", ";", "else", "if", "(", "!", "rtx_equal_p", "(", "a", ",", "b", ")", ")", "return", "false", ";", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "cfun", "->", "machine", "->", "call_abi", "==", "MS_ABI", "&&", "ix86_function_type_abi", "(", "type", ")", "==", "SYSV_ABI", ")", "return", "false", ";", "}", "else", "{", "if", "(", "!", "decl", "||", "(", "bind_global", "&&", "flag_pic", "&&", "!", "flag_plt", ")", "||", "(", "TARGET_DLLIMPORT_DECL_ATTRIBUTES", "&&", "DECL_DLLIMPORT_P", "(", "decl", ")", ")", ")", "{", "if", "(", "ix86_function_regparm", "(", "type", ",", "NULL", ")", ">=", "3", "&&", "!", "cfun", "->", "machine", "->", "arg_reg_available", ")", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</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", "." ]

[ "i386", "3" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "MCInst", "&", "Res", ")", "const", "{", "}", "</s>" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

[ "Mips" ]

[]

[ "<s>", "void", "HexagonPassConfig", "::", "addPreEmitPass", "(", ")", "{", "bool", "NoOpt", "=", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ";", "if", "(", "!", "NoOpt", ")", "addPass", "(", "createHexagonNewValueJump", "(", ")", ")", ";", "addPass", "(", "createHexagonBranchRelaxation", "(", ")", ")", ";", "if", "(", "!", "NoOpt", ")", "{", "if", "(", "!", "DisableHardwareLoops", ")", "addPass", "(", "createHexagonFixupHwLoops", "(", ")", ")", ";", "if", "(", "EnableGenMux", ")", "addPass", "(", "createHexagonGenMux", "(", ")", ")", ";", "}", "addPass", "(", "createHexagonPacketizer", "(", "NoOpt", ")", ")", ";", "if", "(", "EnableVectorPrint", ")", "addPass", "(", "createHexagonVectorPrint", "(", ")", ")", ";", "addPass", "(", "createHexagonCallFrameInformation", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "find_first", "(", ")", "const", "{", "int", "First", "=", "Bits", ".", "find_first", "(", ")", ";", "if", "(", "First", "<", "0", ")", "return", "0", ";", "return", "x2v", "(", "First", ")", ";", "}", "</s>" ]

[ "find_first", "-", "Returns", "the", "index", "of", "the", "first", "set", "bit", "." ]

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

[]

[ "<s>", "static", "void", "m68hc11_reorg", "(", "void", ")", "{", "int", "split_done", "=", "0", ";", "rtx", "insn", ",", "first", ";", "z_replacement_completed", "=", "0", ";", "z_reg", "=", "gen_rtx_REG", "(", "HImode", ",", "HARD_Z_REGNUM", ")", ";", "first", "=", "get_insns", "(", ")", ";", "unshare_all_rtl_again", "(", "first", ")", ";", "split_all_insns_noflow", "(", ")", ";", "split_done", "=", "1", ";", "z_replacement_completed", "=", "1", ";", "m68hc11_reassign_regs", "(", "first", ")", ";", "if", "(", "optimize", ")", "compute_bb_for_insn", "(", ")", ";", "if", "(", "optimize", ">", "0", "&&", "split_done", ")", "{", "reload_cse_regs", "(", "first", ")", ";", "}", "if", "(", "optimize", ")", "{", "for", "(", "insn", "=", "first", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "rtx", "*", "pnote", ";", "pnote", "=", "&", "REG_NOTES", "(", "insn", ")", ";", "while", "(", "*", "pnote", "!=", "0", ")", "{", "if", "(", "REG_NOTE_KIND", "(", "*", "pnote", ")", "==", "REG_DEAD", ")", "*", "pnote", "=", "XEXP", "(", "*", "pnote", ",", "1", ")", ";", "else", "pnote", "=", "&", "XEXP", "(", "*", "pnote", ",", "1", ")", ";", "}", "}", "}", "life_analysis", "(", "0", ",", "PROP_REG_INFO", "|", "PROP_DEATH_NOTES", ")", ";", "}", "z_replacement_completed", "=", "2", ";", "if", "(", "optimize", ">", "0", ")", "split_all_insns_noflow", "(", ")", ";", "{", "rtx", "insn", ";", "for", "(", "insn", "=", "first", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "rtx", "body", ";", "if", "(", "INSN_DELETED_P", "(", "insn", ")", ")", "continue", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "continue", ";", "body", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "SET", "&&", "rtx_equal_p", "(", "SET_SRC", "(", "body", ")", ",", "SET_DEST", "(", "body", ")", ")", ")", "{", "PUT_CODE", "(", "insn", ",", "NOTE", ")", ";", "NOTE_LINE_NUMBER", "(", "insn", ")", "=", "NOTE_INSN_DELETED", ";", "NOTE_SOURCE_FILE", "(", "insn", ")", "=", "0", ";", "continue", ";", "}", "}", "}", "}", "</s>" ]

[ "Machine-dependent", "reorg", "pass", ".", "Specific", "optimizations", "are", "defined", "here", ":", "-", "this", "pass", "changes", "the", "Z", "register", "into", "either", "X", "or", "Y", "(", "it", "preserves", "X/Y", "previous", "values", "in", "a", "memory", "slot", "in", "page0", ")", ".", "When", "this", "pass", "is", "finished", ",", "the", "global", "variable", "'z_replacement_completed", "'", "is", "set", "to", "2", "." ]

[ "m68hc11", "0", "0", "1", "1", "0", "0", "1", "1", "0", "2", "0", "0" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "needsFrameBaseReg", "(", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "assert", "(", "Offset", "<", "0", "&&", "\"Local offset must be negative\"", ")", ";", "unsigned", "OpC", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "!", "ImmToIdxMap", ".", "count", "(", "OpC", ")", ")", "return", "false", ";", "if", "(", "(", "OpC", "==", "PPC", "::", "ADDI", "||", "OpC", "==", "PPC", "::", "ADDI8", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "return", "false", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "unsigned", "StackEst", "=", "TFI", "->", "determineFrameLayout", "(", "MF", ",", "true", ")", ";", "if", "(", "!", "StackEst", ")", "return", "false", ";", "Offset", "+=", "StackEst", ";", "return", "!", "isFrameOffsetLegal", "(", "MI", ",", "getBaseRegister", "(", "MF", ")", ",", "Offset", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "'s", "frame", "index", "reference", "would", "be", "better", "served", "by", "a", "base", "register", "other", "than", "FP", "or", "SP", "." ]

[ "PowerPC", "PPC", "0", "\"Local offset must be negative\"", "PPC::ADDI", "PPC::ADDI8", "2", "0", "PPC" ]

[]

[ "<s>", "void", "XtensaInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "fitsReadPortLimitations", "(", "const", "std", "::", "vector", "<", "MachineInstr", "*", ">", "&", "IG", ",", "const", "DenseMap", "<", "unsigned", ",", "unsigned", ">", "&", "PV", ",", "std", "::", "vector", "<", "BankSwizzle", ">", "&", "ValidSwizzle", ",", "bool", "isLastAluTrans", ")", "const", "{", "std", "::", "vector", "<", "std", "::", "vector", "<", "std", "::", "pair", "<", "int", ",", "unsigned", ">", ">", ">", "IGSrcs", ";", "ValidSwizzle", ".", "clear", "(", ")", ";", "unsigned", "ConstCount", ";", "BankSwizzle", "TransBS", "=", "ALU_VEC_012_SCL_210", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "IG", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "IGSrcs", ".", "push_back", "(", "ExtractSrcs", "(", "IG", "[", "i", "]", ",", "PV", ",", "ConstCount", ")", ")", ";", "unsigned", "Op", "=", "getOperandIdx", "(", "IG", "[", "i", "]", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "bank_swizzle", ")", ";", "ValidSwizzle", ".", "push_back", "(", "(", "R600InstrInfo", "::", "BankSwizzle", ")", "IG", "[", "i", "]", "->", "getOperand", "(", "Op", ")", ".", "getImm", "(", ")", ")", ";", "}", "std", "::", "vector", "<", "std", "::", "pair", "<", "int", ",", "unsigned", ">", ">", "TransOps", ";", "if", "(", "!", "isLastAluTrans", ")", "return", "FindSwizzleForVectorSlot", "(", "IGSrcs", ",", "ValidSwizzle", ",", "TransOps", ",", "TransBS", ")", ";", "TransOps", "=", "std", "::", "move", "(", "IGSrcs", ".", "back", "(", ")", ")", ";", "IGSrcs", ".", "pop_back", "(", ")", ";", "ValidSwizzle", ".", "pop_back", "(", ")", ";", "static", "const", "R600InstrInfo", "::", "BankSwizzle", "TransSwz", "[", "]", "=", "{", "ALU_VEC_012_SCL_210", ",", "ALU_VEC_021_SCL_122", ",", "ALU_VEC_120_SCL_212", ",", "ALU_VEC_102_SCL_221", "}", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "{", "TransBS", "=", "TransSwz", "[", "i", "]", ";", "if", "(", "!", "isConstCompatible", "(", "TransBS", ",", "TransOps", ",", "ConstCount", ")", ")", "continue", ";", "bool", "Result", "=", "FindSwizzleForVectorSlot", "(", "IGSrcs", ",", "ValidSwizzle", ",", "TransOps", ",", "TransBS", ")", ";", "if", "(", "Result", ")", "{", "ValidSwizzle", ".", "push_back", "(", "TransBS", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Given", "the", "order", "VEC_012", "<", "VEC_021", "<", "VEC_120", "<", "VEC_102", "<", "VEC_201", "<", "VEC_210", "returns", "true", "and", "the", "first", "(", "in", "lexical", "order", ")", "BankSwizzle", "affectation", "starting", "from", "the", "one", "already", "provided", "in", "the", "Instruction", "Group", "MIs", "that", "fits", "Read", "Port", "limitations", "in", "BS", "if", "available", "." ]

[ "R600", "0", "0", "4" ]

[]

[ "<s>", "static", "void", "tilepro_reorg", "(", "void", ")", "{", "compute_bb_for_insn", "(", ")", ";", "if", "(", "flag_reorder_blocks_and_partition", ")", "{", "tilepro_fixup_pcrel_references", "(", ")", ";", "}", "if", "(", "flag_schedule_insns_after_reload", ")", "{", "split_all_insns", "(", ")", ";", "timevar_push", "(", "TV_SCHED2", ")", ";", "schedule_insns", "(", ")", ";", "timevar_pop", "(", "TV_SCHED2", ")", ";", "tilepro_gen_bundles", "(", ")", ";", "}", "df_analyze", "(", ")", ";", "if", "(", "flag_var_tracking", ")", "{", "timevar_push", "(", "TV_VAR_TRACKING", ")", ";", "variable_tracking_main", "(", ")", ";", "reorder_var_tracking_notes", "(", ")", ";", "timevar_pop", "(", "TV_VAR_TRACKING", ")", ";", "}", "df_finish_pass", "(", "false", ")", ";", "}", "</s>" ]

[ "Perform", "machine", "dependent", "operations", "on", "the", "rtl", "chain", "INSNS", "." ]

[ "tilepro" ]

[]

[ "<s>", "void", "DLXRegisterInfo", "::", "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", "." ]

[ "DLX", "DLX" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "HRI", "=", "*", "HST", ".", "getRegisterInfo", "(", ")", ";", "SavedRegs", ".", "resize", "(", "HRI", ".", "getNumRegs", "(", ")", ")", ";", "if", "(", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", "->", "hasEHReturn", "(", ")", ")", "for", "(", "const", "MCPhysReg", "*", "R", "=", "HRI", ".", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "*", "R", ";", "++", "R", ")", "SavedRegs", ".", "set", "(", "*", "R", ")", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "NewRegs", ";", "expandSpillMacros", "(", "MF", ",", "NewRegs", ")", ";", "if", "(", "OptimizeSpillSlots", "&&", "!", "isOptNone", "(", "MF", ")", ")", "optimizeSpillSlots", "(", "MF", ",", "NewRegs", ")", ";", "if", "(", "!", "NewRegs", ".", "empty", "(", ")", "||", "mayOverflowFrameOffset", "(", "MF", ")", ")", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SetVector", "<", "const", "TargetRegisterClass", "*", ">", "SpillRCs", ";", "SpillRCs", ".", "insert", "(", "&", "Hexagon", "::", "IntRegsRegClass", ")", ";", "for", "(", "unsigned", "VR", ":", "NewRegs", ")", "SpillRCs", ".", "insert", "(", "MRI", ".", "getRegClass", "(", "VR", ")", ")", ";", "for", "(", "auto", "*", "RC", ":", "SpillRCs", ")", "{", "if", "(", "!", "needToReserveScavengingSpillSlots", "(", "MF", ",", "HRI", ",", "RC", ")", ")", "continue", ";", "unsigned", "Num", "=", "RC", "==", "&", "Hexagon", "::", "IntRegsRegClass", "?", "NumberScavengerSlots", ":", "1", ";", "unsigned", "S", "=", "RC", "->", "getSize", "(", ")", ",", "A", "=", "RC", "->", "getAlignment", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Num", ";", "i", "++", ")", "{", "int", "NewFI", "=", "MFI", ".", "CreateSpillStackObject", "(", "S", ",", "A", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "NewFI", ")", ";", "}", "}", "}", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "8", "Hexagon::IntRegsRegClass", "Hexagon::IntRegsRegClass", "1", "0" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "STRrs", ":", "case", "ARM", "::", "t2STRs", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "STRi12", ":", "case", "ARM", "::", "t2STRi12", ":", "case", "ARM", "::", "tSTRspi", ":", "case", "ARM", "::", "VSTRD", ":", "case", "ARM", "::", "VSTRS", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VST1q64", ":", "case", "ARM", "::", "VST1d64TPseudo", ":", "case", "ARM", "::", "VST1d64QPseudo", ":", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VSTMQIA", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::STRrs", "ARM::t2STRs", "1", "2", "3", "2", "0", "3", "0", "1", "0", "ARM::STRi12", "ARM::t2STRi12", "ARM::tSTRspi", "ARM::VSTRD", "ARM::VSTRS", "1", "2", "2", "0", "1", "0", "ARM::VST1q64", "ARM::VST1d64TPseudo", "ARM::VST1d64QPseudo", "0", "2", "0", "0", "2", "ARM::VSTMQIA", "1", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "void", "arm_setup_incoming_varargs", "(", "cumulative_args_t", "pcum_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", ",", "int", "second_time", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "pcum", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "int", "nregs", ";", "cfun", "->", "machine", "->", "uses_anonymous_args", "=", "1", ";", "if", "(", "pcum", "->", "pcs_variant", "<=", "ARM_PCS_AAPCS_LOCAL", ")", "{", "nregs", "=", "pcum", "->", "aapcs_ncrn", ";", "if", "(", "nregs", "&", "1", ")", "{", "int", "res", "=", "arm_needs_doubleword_align", "(", "mode", ",", "type", ")", ";", "if", "(", "res", "<", "0", "&&", "warn_psabi", ")", "inform", "(", "input_location", ",", "\"parameter passing for argument of \"", "\"type %qT changed in GCC 7.1\"", ",", "type", ")", ";", "else", "if", "(", "res", ">", "0", ")", "nregs", "++", ";", "}", "}", "else", "nregs", "=", "pcum", "->", "nregs", ";", "if", "(", "nregs", "<", "NUM_ARG_REGS", ")", "*", "pretend_size", "=", "(", "NUM_ARG_REGS", "-", "nregs", ")", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_SETUP_INCOMING_VARARGS", ".", "On", "the", "ARM", ",", "PRETEND_SIZE", "is", "set", "in", "order", "to", "have", "the", "prologue", "push", "the", "last", "named", "arg", "and", "all", "anonymous", "args", "onto", "the", "stack", ".", "XXX", "I", "know", "the", "prologue", "should", "n't", "be", "pushing", "registers", ",", "but", "it", "is", "faster", "that", "way", "." ]

[ "arm", "1", "1", "0", "\"parameter passing for argument of \"", "\"type %qT changed in GCC 7.1\"", "0" ]

[]

[ "<s>", "bool", "HexagonCopyToCombine", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "IsCombinesDisabled", ")", "return", "false", ";", "bool", "HasChanged", "=", "false", ";", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "TRI", "=", "ST", "->", "getRegisterInfo", "(", ")", ";", "TII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "OptForSize", "=", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "OptimizeForSize", ")", ";", "ShouldCombineAggressively", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "<=", "CodeGenOpt", "::", "Default", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "PotentiallyNewifiableTFR", ".", "clear", "(", ")", ";", "findPotentialNewifiableTFRs", "(", "*", "BI", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MI", "=", "BI", "->", "begin", "(", ")", ",", "End", "=", "BI", "->", "end", "(", ")", ";", "MI", "!=", "End", ";", ")", "{", "MachineInstr", "&", "I1", "=", "*", "MI", "++", ";", "if", "(", "I1", ".", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "ShouldCombineAggressively", "&&", "PotentiallyNewifiableTFR", ".", "count", "(", "&", "I1", ")", ")", "continue", ";", "if", "(", "!", "isCombinableInstType", "(", "I1", ",", "TII", ",", "ShouldCombineAggressively", ")", ")", "continue", ";", "bool", "DoInsertAtI1", "=", "false", ";", "DbgMItoMove", ".", "clear", "(", ")", ";", "MachineInstr", "*", "I2", "=", "findPairable", "(", "I1", ",", "DoInsertAtI1", ",", "OptForSize", ")", ";", "if", "(", "I2", ")", "{", "HasChanged", "=", "true", ";", "combine", "(", "I1", ",", "*", "I2", ",", "MI", ",", "DoInsertAtI1", ",", "OptForSize", ")", ";", "}", "}", "}", "return", "HasChanged", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "output_probe_stack_range", "(", "rtx", "reg", ",", "rtx", "end", ")", "{", "static", "int", "labelno", "=", "0", ";", "char", "loop_lab", "[", "32", "]", ";", "rtx", "xops", "[", "3", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "loop_lab", ",", "\"LPSRL\"", ",", "labelno", "++", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "loop_lab", ")", ";", "xops", "[", "0", "]", "=", "reg", ";", "xops", "[", "1", "]", "=", "GEN_INT", "(", "get_probe_interval", "(", ")", ")", ";", "output_asm_insn", "(", "\"sub%z0\\t{%1, %0|%0, %1}\"", ",", "xops", ")", ";", "xops", "[", "0", "]", "=", "stack_pointer_rtx", ";", "xops", "[", "1", "]", "=", "reg", ";", "xops", "[", "2", "]", "=", "const0_rtx", ";", "output_asm_insn", "(", "\"or%z0\\t{%2, (%0,%1)|DWORD PTR [%0+%1], %2}\"", ",", "xops", ")", ";", "xops", "[", "0", "]", "=", "reg", ";", "xops", "[", "1", "]", "=", "end", ";", "output_asm_insn", "(", "\"cmp%z0\\t{%1, %0|%0, %1}\"", ",", "xops", ")", ";", "fputs", "(", "\"\\tjne\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "loop_lab", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Wrapper", "around", "the", "output_probe_stack_range", "routines", "." ]

[ "i386", "0", "32", "3", "\"LPSRL\"", "0", "1", "\"sub%z0\\t{%1, %0|%0, %1}\"", "0", "1", "2", "\"or%z0\\t{%2, (%0,%1)|DWORD PTR [%0+%1], %2}\"", "0", "1", "\"cmp%z0\\t{%1, %0|%0, %1}\"", "\"\\tjne\\t\"", "\"\"" ]

[]

[ "<s>", "static", "rtx_insn", "*", "nds32_md_asm_adjust", "(", "vec", "<", "rtx", ">", "&", "outputs", "ATTRIBUTE_UNUSED", ",", "vec", "<", "rtx", ">", "&", "inputs", "ATTRIBUTE_UNUSED", ",", "vec", "<", "machine_mode", ">", "&", "input_modes", "ATTRIBUTE_UNUSED", ",", "vec", "<", "const", "char", "*", ">", "&", "constraints", "ATTRIBUTE_UNUSED", ",", "vec", "<", "rtx", ">", "&", "clobbers", ",", "HARD_REG_SET", "&", "clobbered_regs", ",", "location_t", ")", "{", "if", "(", "!", "flag_inline_asm_r15", ")", "{", "clobbers", ".", "safe_push", "(", "gen_rtx_REG", "(", "SImode", ",", "TA_REGNUM", ")", ")", ";", "SET_HARD_REG_BIT", "(", "clobbered_regs", ",", "TA_REGNUM", ")", ";", "}", "return", "NULL", ";", "}", "</s>" ]

[ "Miscellaneous", "Parameters", "." ]

[ "nds32" ]

[]

[ "<s>", "int", "nds32_can_use_btgl_p", "(", "int", "ival", ")", "{", "int", "one_bit_count", ";", "one_bit_count", "=", "popcount_hwi", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "(", "ival", ")", ")", ";", "return", "(", "TARGET_EXT_PERF", "&&", "(", "one_bit_count", "==", "1", ")", ")", ";", "}", "</s>" ]

[ "Function", "to", "check", "if", "'btgl", "'", "instruction", "can", "be", "used", "with", "IVAL", "." ]

[ "nds32", "1" ]

[]

[ "<s>", "const", "uint16_t", "*", "MBlazeRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "MBlaze", "::", "R20", ",", "MBlaze", "::", "R21", ",", "MBlaze", "::", "R22", ",", "MBlaze", "::", "R23", ",", "MBlaze", "::", "R24", ",", "MBlaze", "::", "R25", ",", "MBlaze", "::", "R26", ",", "MBlaze", "::", "R27", ",", "MBlaze", "::", "R28", ",", "MBlaze", "::", "R29", ",", "MBlaze", "::", "R30", ",", "MBlaze", "::", "R31", ",", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze::R20", "MBlaze::R21", "MBlaze::R22", "MBlaze::R23", "MBlaze::R24", "MBlaze::R25", "MBlaze::R26", "MBlaze::R27", "MBlaze::R28", "MBlaze::R29", "MBlaze::R30", "MBlaze::R31", "0" ]

[]

[ "<s>", "virtual", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "X86" ]

[]

[ "<s>", "const", "uint16_t", "*", "ARMBaseRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "bool", "ghcCall", "=", "false", ";", "if", "(", "MF", ")", "{", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "ghcCall", "=", "(", "F", "?", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ":", "false", ")", ";", "}", "if", "(", "ghcCall", ")", "{", "return", "CSR_GHC_SaveList", ";", "}", "else", "{", "return", "(", "STI", ".", "isTargetIOS", "(", ")", "&&", "!", "STI", ".", "isAAPCS_ABI", "(", ")", ")", "?", "CSR_iOS_SaveList", ":", "CSR_AAPCS_SaveList", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "unsigned", "int", "arc_compute_frame_size", "(", "void", ")", "{", "int", "regno", ";", "unsigned", "int", "total_size", ",", "var_size", ",", "args_size", ",", "pretend_size", ",", "extra_size", ";", "unsigned", "int", "reg_size", ";", "uint64_t", "gmask", ";", "struct", "arc_frame_info", "*", "frame_info", ";", "int", "size", ";", "unsigned", "int", "extra_plus_reg_size", ";", "unsigned", "int", "extra_plus_reg_size_aligned", ";", "unsigned", "int", "fn_type", "=", "arc_compute_function_type", "(", "cfun", ")", ";", "if", "(", "cfun", "->", "machine", "->", "frame_info", ".", "initialized", ")", "return", "cfun", "->", "machine", "->", "frame_info", ".", "total_size", ";", "frame_info", "=", "&", "cfun", "->", "machine", "->", "frame_info", ";", "size", "=", "ARC_STACK_ALIGN", "(", "get_frame_size", "(", ")", ")", ";", "var_size", "=", "size", ";", "args_size", "=", "crtl", "->", "outgoing_args_size", ";", "reg_size", "=", "0", ";", "gmask", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "(", "GMASK_LEN", "-", "4", ")", ";", "regno", "++", ")", "{", "if", "(", "arc_must_save_register", "(", "regno", ",", "cfun", ",", "false", ")", ")", "{", "reg_size", "+=", "UNITS_PER_WORD", ";", "gmask", "|=", "1ULL", "<<", "regno", ";", "}", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "for", "(", "regno", "=", "0", ";", "EH_RETURN_DATA_REGNO", "(", "regno", ")", "!=", "INVALID_REGNUM", ";", "regno", "++", ")", "{", "reg_size", "+=", "UNITS_PER_WORD", ";", "gmask", "|=", "1ULL", "<<", "regno", ";", "}", "frame_info", "->", "save_return_addr", "=", "(", "!", "crtl", "->", "is_leaf", "||", "df_regs_ever_live_p", "(", "RETURN_ADDR_REGNUM", ")", "||", "crtl", "->", "calls_eh_return", ")", ";", "if", "(", "TARGET_MILLICODE_THUNK_SET", "&&", "!", "ARC_INTERRUPT_P", "(", "fn_type", ")", "&&", "!", "crtl", "->", "calls_eh_return", ")", "{", "if", "(", "arc_compute_millicode_save_restore_regs", "(", "gmask", ",", "frame_info", ")", ")", "frame_info", "->", "save_return_addr", "=", "true", ";", "}", "if", "(", "arc_lpcwidth", "!=", "0", "&&", "arc_must_save_register", "(", "LP_COUNT", ",", "cfun", ",", "true", ")", ")", "reg_size", "+=", "UNITS_PER_WORD", "*", "3", ";", "if", "(", "arc_must_save_register", "(", "TARGET_BIG_ENDIAN", "?", "R41_REG", ":", "R40_REG", ",", "cfun", ",", "TARGET_DPFP", ")", ")", "reg_size", "+=", "UNITS_PER_WORD", "*", "2", ";", "if", "(", "arc_must_save_register", "(", "TARGET_BIG_ENDIAN", "?", "R43_REG", ":", "R42_REG", ",", "cfun", ",", "TARGET_DPFP", ")", ")", "reg_size", "+=", "UNITS_PER_WORD", "*", "2", ";", "if", "(", "arc_must_save_register", "(", "R58_REG", ",", "cfun", ",", "true", ")", ")", "reg_size", "+=", "UNITS_PER_WORD", "*", "2", ";", "extra_size", "=", "0", ";", "if", "(", "arc_must_save_return_addr", "(", "cfun", ")", ")", "extra_size", "=", "4", ";", "if", "(", "arc_frame_pointer_needed", "(", ")", "&&", "!", "ARC_AUTOFP_IRQ_P", "(", "fn_type", ")", ")", "extra_size", "+=", "4", ";", "pretend_size", "=", "crtl", "->", "args", ".", "pretend_args_size", ";", "extra_plus_reg_size", "=", "extra_size", "+", "reg_size", ";", "extra_plus_reg_size_aligned", "=", "ARC_STACK_ALIGN", "(", "extra_plus_reg_size", ")", ";", "reg_size", "=", "extra_plus_reg_size_aligned", "-", "extra_size", ";", "total_size", "=", "var_size", "+", "args_size", "+", "extra_size", "+", "pretend_size", "+", "reg_size", ";", "gcc_assert", "(", "total_size", "==", "ARC_STACK_ALIGN", "(", "total_size", ")", ")", ";", "frame_info", "->", "total_size", "=", "total_size", ";", "frame_info", "->", "extra_size", "=", "extra_size", ";", "frame_info", "->", "pretend_size", "=", "pretend_size", ";", "frame_info", "->", "var_size", "=", "var_size", ";", "frame_info", "->", "args_size", "=", "args_size", ";", "frame_info", "->", "reg_size", "=", "reg_size", ";", "frame_info", "->", "gmask", "=", "gmask", ";", "frame_info", "->", "initialized", "=", "reload_completed", ";", "return", "total_size", ";", "}", "</s>" ]

[ "Return", "the", "bytes", "needed", "to", "compute", "the", "frame", "pointer", "from", "the", "current", "stack", "pointer", ".", "SIZE", "is", "the", "size", "needed", "for", "local", "variables", "." ]

[ "arc", "0", "0", "0", "4", "1ULL", "0", "1ULL", "0", "3", "2", "2", "2", "0", "4", "4" ]

[]

[ "<s>", "static", "bool", "loongarch_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "return", "loongarch_hard_regno_mode_ok_p", "[", "mode", "]", "[", "regno", "]", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", "." ]

[ "loongarch" ]

[]

[ "<s>", "static", "bool", "mips_lo_sum_offset_lookup", "(", "mips_offset_table", "*", "htab", ",", "rtx", "x", ",", "enum", "insert_option", "option", ")", "{", "rtx", "base", ",", "offset", ";", "mips_lo_sum_offset", "*", "*", "slot", ";", "struct", "mips_lo_sum_offset", "*", "entry", ";", "split_const", "(", "x", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "UNSPEC_ADDRESS_P", "(", "base", ")", ")", "base", "=", "UNSPEC_ADDRESS", "(", "base", ")", ";", "slot", "=", "htab", "->", "find_slot_with_hash", "(", "base", ",", "mips_hash_base", "(", "base", ")", ",", "option", ")", ";", "if", "(", "slot", "==", "NULL", ")", "return", "false", ";", "entry", "=", "(", "struct", "mips_lo_sum_offset", "*", ")", "*", "slot", ";", "if", "(", "option", "==", "INSERT", ")", "{", "if", "(", "entry", "==", "NULL", ")", "{", "entry", "=", "XNEW", "(", "struct", "mips_lo_sum_offset", ")", ";", "entry", "->", "base", "=", "base", ";", "entry", "->", "offset", "=", "INTVAL", "(", "offset", ")", ";", "*", "slot", "=", "entry", ";", "}", "else", "{", "if", "(", "INTVAL", "(", "offset", ")", ">", "entry", "->", "offset", ")", "entry", "->", "offset", "=", "INTVAL", "(", "offset", ")", ";", "}", "}", "return", "INTVAL", "(", "offset", ")", "<=", "entry", "->", "offset", ";", "}", "</s>" ]

[ "Look", "up", "symbolic", "constant", "X", "in", "HTAB", ",", "which", "is", "a", "hash", "table", "of", "mips_lo_sum_offsets", ".", "If", "OPTION", "is", "NO_INSERT", ",", "return", "true", "if", "X", "can", "be", "paired", "with", "a", "recorded", "LO_SUM", ",", "otherwise", "record", "X", "in", "the", "table", "." ]

[ "mips" ]

[]

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

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

[ "Teak", "\"Expr shouldn't be null!\"" ]

[]

[ "<s>", "inline", "machine_mode", "function_instance", "::", "memory_vector_mode", "(", ")", "const", "{", "return", "base", "->", "memory_vector_mode", "(", "*", "this", ")", ";", "}", "</s>" ]

[ "If", "the", "function", "addresses", "memory", ",", "return", "a", "vector", "mode", "whose", "GET_MODE_NUNITS", "is", "the", "number", "of", "elements", "addressed", "and", "whose", "GET_MODE_INNER", "is", "the", "mode", "of", "a", "single", "scalar", "memory", "element", "." ]

[ "aarch64" ]

[]

[ "<s>", "TargetTransformInfo", "RISCVTargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "const", "{", "return", "TargetTransformInfo", "(", "RISCVTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetTransformInfo", "implementation", "for", "the", "target", "." ]

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

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "PerformEXTRACT_VECTOR_ELTCombine", "(", "N", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "PerformSELECTCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "X86ISD", "::", "CMOV", ":", "return", "PerformCMOVCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "return", "OptimizeConditonalInDecrement", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "ADC", ":", "return", "PerformADCCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMulCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "PerformShiftCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "PerformAndCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformOrCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "PerformSTORECombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "X86ISD", "::", "FXOR", ":", "case", "X86ISD", "::", "FOR", ":", "return", "PerformFORCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "FAND", ":", "return", "PerformFANDCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "BT", ":", "return", "PerformBTCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "X86ISD", "::", "VZEXT_MOVL", ":", "return", "PerformVZEXT_MOVLCombine", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "PerformZExtCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "SETCC", ":", "return", "PerformSETCCCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "SHUFPS", ":", "case", "X86ISD", "::", "SHUFPD", ":", "case", "X86ISD", "::", "PALIGN", ":", "case", "X86ISD", "::", "PUNPCKHBW", ":", "case", "X86ISD", "::", "PUNPCKHWD", ":", "case", "X86ISD", "::", "PUNPCKHDQ", ":", "case", "X86ISD", "::", "PUNPCKHQDQ", ":", "case", "X86ISD", "::", "UNPCKHPS", ":", "case", "X86ISD", "::", "UNPCKHPD", ":", "case", "X86ISD", "::", "PUNPCKLBW", ":", "case", "X86ISD", "::", "PUNPCKLWD", ":", "case", "X86ISD", "::", "PUNPCKLDQ", ":", "case", "X86ISD", "::", "PUNPCKLQDQ", ":", "case", "X86ISD", "::", "UNPCKLPS", ":", "case", "X86ISD", "::", "UNPCKLPD", ":", "case", "X86ISD", "::", "VUNPCKLPS", ":", "case", "X86ISD", "::", "VUNPCKLPD", ":", "case", "X86ISD", "::", "VUNPCKLPSY", ":", "case", "X86ISD", "::", "VUNPCKLPDY", ":", "case", "X86ISD", "::", "MOVHLPS", ":", "case", "X86ISD", "::", "MOVLHPS", ":", "case", "X86ISD", "::", "PSHUFD", ":", "case", "X86ISD", "::", "PSHUFHW", ":", "case", "X86ISD", "::", "PSHUFLW", ":", "case", "X86ISD", "::", "MOVSS", ":", "case", "X86ISD", "::", "MOVSD", ":", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "PerformShuffleCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "X86", "X86", "ISD::EXTRACT_VECTOR_ELT", "ISD::SELECT", "X86ISD::CMOV", "ISD::ADD", "ISD::SUB", "X86ISD::ADC", "ISD::MUL", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::AND", "ISD::OR", "ISD::STORE", "X86ISD::FXOR", "X86ISD::FOR", "X86ISD::FAND", "X86ISD::BT", "X86ISD::VZEXT_MOVL", "ISD::ZERO_EXTEND", "X86ISD::SETCC", "X86ISD::SHUFPS", "X86ISD::SHUFPD", "X86ISD::PALIGN", "X86ISD::PUNPCKHBW", "X86ISD::PUNPCKHWD", "X86ISD::PUNPCKHDQ", "X86ISD::PUNPCKHQDQ", "X86ISD::UNPCKHPS", "X86ISD::UNPCKHPD", "X86ISD::PUNPCKLBW", "X86ISD::PUNPCKLWD", "X86ISD::PUNPCKLDQ", "X86ISD::PUNPCKLQDQ", "X86ISD::UNPCKLPS", "X86ISD::UNPCKLPD", "X86ISD::VUNPCKLPS", "X86ISD::VUNPCKLPD", "X86ISD::VUNPCKLPSY", "X86ISD::VUNPCKLPDY", "X86ISD::MOVHLPS", "X86ISD::MOVLHPS", "X86ISD::PSHUFD", "X86ISD::PSHUFHW", "X86ISD::PSHUFLW", "X86ISD::MOVSS", "X86ISD::MOVSD", "ISD::VECTOR_SHUFFLE" ]

[]

[ "<s>", "static", "bool", "use_rsqrt_p", "(", ")", "{", "return", "(", "TARGET_SSE_MATH", "&&", "flag_finite_math_only", "&&", "!", "flag_trapping_math", "&&", "flag_unsafe_math_optimizations", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "safe", "to", "use", "the", "rsqrt", "optabs", "to", "optimize", "1.0/sqrt", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "nvptx_reorg", "(", "void", ")", "{", "compute_bb_for_insn", "(", ")", ";", "thread_prologue_and_epilogue_insns", "(", ")", ";", "bb_insn_map_t", "bb_insn_map", ";", "nvptx_split_blocks", "(", "&", "bb_insn_map", ")", ";", "df_clear_flags", "(", "DF_LR_RUN_DCE", ")", ";", "df_set_flags", "(", "DF_NO_INSN_RESCAN", "|", "DF_NO_HARD_REGS", ")", ";", "df_live_add_problem", "(", ")", ";", "df_live_set_all_dirty", "(", ")", ";", "df_analyze", "(", ")", ";", "regstat_init_n_sets_and_refs", "(", ")", ";", "if", "(", "dump_file", ")", "df_dump", "(", "dump_file", ")", ";", "int", "max_regs", "=", "max_reg_num", "(", ")", ";", "for", "(", "int", "i", "=", "LAST_VIRTUAL_REGISTER", "+", "1", ";", "i", "<", "max_regs", ";", "i", "++", ")", "if", "(", "REG_N_SETS", "(", "i", ")", "==", "0", "&&", "REG_N_REFS", "(", "i", ")", "==", "0", ")", "regno_reg_rtx", "[", "i", "]", "=", "const0_rtx", ";", "tree", "attr", "=", "get_oacc_fn_attrib", "(", "current_function_decl", ")", ";", "if", "(", "attr", ")", "{", "unsigned", "mask", "=", "0", ";", "tree", "dims", "=", "TREE_VALUE", "(", "attr", ")", ";", "unsigned", "ix", ";", "for", "(", "ix", "=", "0", ";", "ix", "!=", "GOMP_DIM_MAX", ";", "ix", "++", ",", "dims", "=", "TREE_CHAIN", "(", "dims", ")", ")", "{", "int", "size", "=", "TREE_INT_CST_LOW", "(", "TREE_VALUE", "(", "dims", ")", ")", ";", "tree", "allowed", "=", "TREE_PURPOSE", "(", "dims", ")", ";", "if", "(", "size", "!=", "1", "&&", "!", "(", "allowed", "&&", "integer_zerop", "(", "allowed", ")", ")", ")", "mask", "|=", "GOMP_DIM_MASK", "(", "ix", ")", ";", "}", "gcc_assert", "(", "!", "(", "mask", "&", "GOMP_DIM_MASK", "(", "GOMP_DIM_WORKER", ")", ")", "||", "(", "mask", "&", "GOMP_DIM_MASK", "(", "GOMP_DIM_VECTOR", ")", ")", ")", ";", "parallel", "*", "pars", "=", "nvptx_discover_pars", "(", "&", "bb_insn_map", ")", ";", "nvptx_process_pars", "(", "pars", ")", ";", "nvptx_neuter_pars", "(", "pars", ",", "mask", ",", "0", ")", ";", "delete", "pars", ";", "}", "nvptx_reorg_subreg", "(", ")", ";", "regstat_free_n_sets_and_refs", "(", ")", ";", "df_finish_pass", "(", "true", ")", ";", "}", "</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", "1", "0", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "SDValue", "R600TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "R600MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "R600MachineFunctionInfo", ">", "(", ")", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "8", ">", "LocalIns", ";", "getOriginalFunctionArgs", "(", "DAG", ",", "MF", ".", "getFunction", "(", ")", ",", "Ins", ",", "LocalIns", ")", ";", "AnalyzeFormalArguments", "(", "CCInfo", ",", "LocalIns", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "const", "ISD", "::", "InputArg", "&", "In", "=", "Ins", "[", "i", "]", ";", "EVT", "VT", "=", "In", ".", "VT", ";", "EVT", "MemVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", "&&", "MemVT", ".", "isVector", "(", ")", ")", "{", "MemVT", "=", "MemVT", ".", "getVectorElementType", "(", ")", ";", "}", "if", "(", "AMDGPU", "::", "isShader", "(", "CallConv", ")", ")", "{", "unsigned", "Reg", "=", "MF", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "&", "AMDGPU", "::", "R600_Reg128RegClass", ")", ";", "SDValue", "Register", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "VT", ")", ";", "InVals", ".", "push_back", "(", "Register", ")", ";", "continue", ";", "}", "PointerType", "*", "PtrTy", "=", "PointerType", "::", "get", "(", "VT", ".", "getTypeForEVT", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "AMDGPUAS", "::", "CONSTANT_BUFFER_0", ")", ";", "ISD", "::", "LoadExtType", "Ext", "=", "ISD", "::", "NON_EXTLOAD", ";", "if", "(", "MemVT", ".", "getScalarSizeInBits", "(", ")", "!=", "VT", ".", "getScalarSizeInBits", "(", ")", ")", "{", "Ext", "=", "ISD", "::", "SEXTLOAD", ";", "}", "unsigned", "ValBase", "=", "ArgLocs", "[", "In", ".", "getOrigArgIndex", "(", ")", "]", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "PartOffset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "Offset", "=", "36", "+", "VA", ".", "getLocMemOffset", "(", ")", ";", "MachinePointerInfo", "PtrInfo", "(", "UndefValue", "::", "get", "(", "PtrTy", ")", ",", "PartOffset", "-", "ValBase", ")", ";", "SDValue", "Arg", "=", "DAG", ".", "getLoad", "(", "ISD", "::", "UNINDEXED", ",", "Ext", ",", "VT", ",", "DL", ",", "Chain", ",", "DAG", ".", "getConstant", "(", "Offset", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getUNDEF", "(", "MVT", "::", "i32", ")", ",", "PtrInfo", ",", "MemVT", ",", "false", ",", "true", ",", "true", ",", "4", ")", ";", "InVals", ".", "push_back", "(", "Arg", ")", ";", "MFI", "->", "ABIArgOffset", "=", "Offset", "+", "MemVT", ".", "getStoreSize", "(", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "ISD::InputArg", "16", "R600", "R600", "ISD::InputArg", "8", "0", "ISD::InputArg", "AMDGPU::isShader", "AMDGPU::R600_Reg128RegClass", "AMDGPU", "ISD::LoadExtType", "ISD::NON_EXTLOAD", "ISD::SEXTLOAD", "36", "ISD::UNINDEXED", "MVT::i32", "MVT::i32", "4" ]

[]

[ "<s>", "SNESTargetLowering", "::", "ConstraintType", "SNESTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'a'", ":", "case", "'b'", ":", "case", "'d'", ":", "case", "'l'", ":", "case", "'e'", ":", "case", "'q'", ":", "case", "'r'", ":", "case", "'w'", ":", "return", "C_RegisterClass", ";", "case", "'t'", ":", "case", "'x'", ":", "case", "'X'", ":", "case", "'y'", ":", "case", "'Y'", ":", "case", "'z'", ":", "case", "'Z'", ":", "return", "C_Register", ";", "case", "'Q'", ":", "return", "C_Memory", ";", "case", "'G'", ":", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "case", "'N'", ":", "case", "'O'", ":", "case", "'P'", ":", "case", "'R'", ":", "return", "C_Other", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "SNES", "SNES", "SNES", "1", "0" ]

[]

[ "<s>", "static", "enum", "rtx_code", "ix86_prepare_fp_compare_args", "(", "enum", "rtx_code", "code", ",", "rtx", "*", "pop0", ",", "rtx", "*", "pop1", ")", "{", "bool", "unordered_compare", "=", "ix86_unordered_fp_compare", "(", "code", ")", ";", "rtx", "op0", "=", "*", "pop0", ",", "op1", "=", "*", "pop1", ";", "machine_mode", "op_mode", "=", "GET_MODE", "(", "op0", ")", ";", "bool", "is_sse", "=", "SSE_FLOAT_MODE_SSEMATH_OR_HF_P", "(", "op_mode", ")", ";", "if", "(", "!", "is_sse", "&&", "(", "unordered_compare", "||", "(", "op_mode", "==", "XFmode", "&&", "!", "(", "standard_80387_constant_p", "(", "op0", ")", "==", "1", "||", "standard_80387_constant_p", "(", "op1", ")", "==", "1", ")", "&&", "GET_CODE", "(", "op1", ")", "!=", "FLOAT", ")", "||", "ix86_fp_comparison_strategy", "(", "code", ")", "==", "IX86_FPCMP_COMI", ")", ")", "{", "op0", "=", "force_reg", "(", "op_mode", ",", "op0", ")", ";", "op1", "=", "force_reg", "(", "op_mode", ",", "op1", ")", ";", "}", "else", "{", "if", "(", "standard_80387_constant_p", "(", "op0", ")", "==", "0", "||", "(", "MEM_P", "(", "op0", ")", "&&", "!", "(", "standard_80387_constant_p", "(", "op1", ")", "==", "0", "||", "MEM_P", "(", "op1", ")", ")", ")", ")", "{", "enum", "rtx_code", "new_code", "=", "ix86_fp_swap_condition", "(", "code", ")", ";", "if", "(", "new_code", "!=", "UNKNOWN", ")", "{", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "code", "=", "new_code", ";", "}", "}", "if", "(", "!", "REG_P", "(", "op0", ")", ")", "op0", "=", "force_reg", "(", "op_mode", ",", "op0", ")", ";", "if", "(", "CONSTANT_P", "(", "op1", ")", ")", "{", "int", "tmp", "=", "standard_80387_constant_p", "(", "op1", ")", ";", "if", "(", "tmp", "==", "0", ")", "op1", "=", "validize_mem", "(", "force_const_mem", "(", "op_mode", ",", "op1", ")", ")", ";", "else", "if", "(", "tmp", "==", "1", ")", "{", "if", "(", "TARGET_CMOVE", ")", "op1", "=", "force_reg", "(", "op_mode", ",", "op1", ")", ";", "}", "else", "op1", "=", "force_reg", "(", "op_mode", ",", "op1", ")", ";", "}", "}", "if", "(", "ix86_fp_comparison_cost", "(", "code", ")", ">", "ix86_fp_comparison_cost", "(", "swap_condition", "(", "code", ")", ")", "&&", "(", "REG_P", "(", "op1", ")", "||", "can_create_pseudo_p", "(", ")", ")", ")", "{", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "if", "(", "!", "REG_P", "(", "op0", ")", ")", "op0", "=", "force_reg", "(", "op_mode", ",", "op0", ")", ";", "}", "*", "pop0", "=", "op0", ";", "*", "pop1", "=", "op1", ";", "return", "code", ";", "}", "</s>" ]

[ "Swap", ",", "force", "into", "registers", ",", "or", "otherwise", "massage", "the", "two", "operands", "to", "a", "fp", "comparison", ".", "The", "operands", "are", "updated", "in", "place", ";", "the", "new", "comparsion", "code", "is", "returned", "." ]

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

[]

[ "<s>", "void", "ia64_split_return_addr_rtx", "(", "rtx", "dest", ")", "{", "rtx", "src", ";", "if", "(", "TEST_HARD_REG_BIT", "(", "current_frame_info", ".", "mask", ",", "BR_REG", "(", "0", ")", ")", ")", "{", "if", "(", "current_frame_info", ".", "r", "[", "reg_save_b0", "]", "!=", "0", ")", "{", "src", "=", "gen_rtx_REG", "(", "DImode", ",", "current_frame_info", ".", "r", "[", "reg_save_b0", "]", ")", ";", "reg_emitted", "(", "reg_save_b0", ")", ";", "}", "else", "{", "HOST_WIDE_INT", "off", ";", "unsigned", "int", "regno", ";", "rtx", "off_r", ";", "off", "=", "(", "current_frame_info", ".", "spill_cfa_off", "+", "current_frame_info", ".", "spill_size", ")", ";", "for", "(", "regno", "=", "GR_REG", "(", "1", ")", ";", "regno", "<=", "GR_REG", "(", "31", ")", ";", "++", "regno", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "current_frame_info", ".", "mask", ",", "regno", ")", ")", "off", "-=", "8", ";", "if", "(", "frame_pointer_needed", ")", "src", "=", "hard_frame_pointer_rtx", ";", "else", "{", "src", "=", "stack_pointer_rtx", ";", "off", "+=", "current_frame_info", ".", "total_size", ";", "}", "off_r", "=", "GEN_INT", "(", "off", ")", ";", "if", "(", "satisfies_constraint_I", "(", "off_r", ")", ")", "emit_insn", "(", "gen_adddi3", "(", "dest", ",", "src", ",", "off_r", ")", ")", ";", "else", "{", "emit_move_insn", "(", "dest", ",", "off_r", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "dest", ",", "src", ",", "dest", ")", ")", ";", "}", "src", "=", "gen_rtx_MEM", "(", "Pmode", ",", "dest", ")", ";", "}", "}", "else", "src", "=", "gen_rtx_REG", "(", "DImode", ",", "BR_REG", "(", "0", ")", ")", ";", "emit_move_insn", "(", "dest", ",", "src", ")", ";", "}", "</s>" ]

[ "Split", "this", "value", "after", "reload", ",", "now", "that", "we", "know", "where", "the", "return", "address", "is", "saved", "." ]

[ "ia64", "0", "0", "1", "31", "8", "0" ]

[]

[ "<s>", "static", "void", "alpha_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "chain_value", ")", "{", "rtx", "fnaddr", ",", "mem", ",", "word1", ",", "word2", ";", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "fnaddr", "=", "convert_memory_address", "(", "Pmode", ",", "fnaddr", ")", ";", "chain_value", "=", "convert_memory_address", "(", "Pmode", ",", "chain_value", ")", ";", "if", "(", "TARGET_ABI_OPEN_VMS", ")", "{", "const", "char", "*", "fnname", ";", "char", "*", "trname", ";", "fnname", "=", "XSTR", "(", "fnaddr", ",", "0", ")", ";", "trname", "=", "(", "char", "*", ")", "alloca", "(", "strlen", "(", "fnname", ")", "+", "5", ")", ";", "strcpy", "(", "trname", ",", "fnname", ")", ";", "strcat", "(", "trname", ",", "\"..tr\"", ")", ";", "fnname", "=", "ggc_alloc_string", "(", "trname", ",", "strlen", "(", "trname", ")", "+", "1", ")", ";", "word2", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "fnname", ")", ";", "word1", "=", "force_reg", "(", "DImode", ",", "gen_const_mem", "(", "DImode", ",", "fnaddr", ")", ")", ";", "word1", "=", "expand_and", "(", "DImode", ",", "word1", ",", "GEN_INT", "(", "HOST_WIDE_INT_C", "(", "0xffff0fff0000fff0", ")", ")", ",", "NULL", ")", ";", "}", "else", "{", "word1", "=", "GEN_INT", "(", "HOST_WIDE_INT_C", "(", "0xa77b0010a43b0018", ")", ")", ";", "word2", "=", "GEN_INT", "(", "HOST_WIDE_INT_C", "(", "0x47ff041f6bfb0000", ")", ")", ";", "}", "mem", "=", "adjust_address", "(", "m_tramp", ",", "DImode", ",", "0", ")", ";", "emit_move_insn", "(", "mem", ",", "word1", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "DImode", ",", "8", ")", ";", "emit_move_insn", "(", "mem", ",", "word2", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "16", ")", ";", "emit_move_insn", "(", "mem", ",", "fnaddr", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "24", ")", ";", "emit_move_insn", "(", "mem", ",", "chain_value", ")", ";", "if", "(", "TARGET_ABI_OSF", ")", "{", "emit_insn", "(", "gen_imb", "(", ")", ")", ";", "emit_library_call", "(", "init_one_libfunc", "(", "\"__enable_execute_stack\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "1", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ",", "Pmode", ")", ";", "}", "}", "</s>" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", "at", "M_TRAMP", ".", "FNDECL", "is", "target", "function", "'s", "decl", ".", "CHAIN_VALUE", "is", "an", "rtx", "for", "the", "static", "chain", "value", "for", "the", "function", "." ]

[ "alpha", "0", "0", "5", "\"..tr\"", "1", "0xffff0fff0000fff0", "0xa77b0010a43b0018", "0x47ff041f6bfb0000", "0", "8", "16", "24", "\"__enable_execute_stack\"", "1", "0" ]

[]

[ "<s>", "bool", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "override", "{", "switch", "(", "(", "Sparc", "::", "Fixups", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Sparc", "::", "fixup_sparc_wplt30", ":", "if", "(", "Target", ".", "getSymA", "(", ")", "->", "getSymbol", "(", ")", ".", "isTemporary", "(", ")", ")", "return", "false", ";", "LLVM_FALLTHROUGH", ";", "case", "Sparc", "::", "fixup_sparc_tls_gd_hi22", ":", "case", "Sparc", "::", "fixup_sparc_tls_gd_lo10", ":", "case", "Sparc", "::", "fixup_sparc_tls_gd_add", ":", "case", "Sparc", "::", "fixup_sparc_tls_gd_call", ":", "case", "Sparc", "::", "fixup_sparc_tls_ldm_hi22", ":", "case", "Sparc", "::", "fixup_sparc_tls_ldm_lo10", ":", "case", "Sparc", "::", "fixup_sparc_tls_ldm_add", ":", "case", "Sparc", "::", "fixup_sparc_tls_ldm_call", ":", "case", "Sparc", "::", "fixup_sparc_tls_ldo_hix22", ":", "case", "Sparc", "::", "fixup_sparc_tls_ldo_lox10", ":", "case", "Sparc", "::", "fixup_sparc_tls_ldo_add", ":", "case", "Sparc", "::", "fixup_sparc_tls_ie_hi22", ":", "case", "Sparc", "::", "fixup_sparc_tls_ie_lo10", ":", "case", "Sparc", "::", "fixup_sparc_tls_ie_ld", ":", "case", "Sparc", "::", "fixup_sparc_tls_ie_ldx", ":", "case", "Sparc", "::", "fixup_sparc_tls_ie_add", ":", "case", "Sparc", "::", "fixup_sparc_tls_le_hix22", ":", "case", "Sparc", "::", "fixup_sparc_tls_le_lox10", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Hook", "to", "check", "if", "a", "relocation", "is", "needed", "for", "some", "target", "specific", "reason", "." ]

[ "Sparc", "Sparc::Fixups", "Sparc::fixup_sparc_wplt30", "Sparc::fixup_sparc_tls_gd_hi22", "Sparc::fixup_sparc_tls_gd_lo10", "Sparc::fixup_sparc_tls_gd_add", "Sparc::fixup_sparc_tls_gd_call", "Sparc::fixup_sparc_tls_ldm_hi22", "Sparc::fixup_sparc_tls_ldm_lo10", "Sparc::fixup_sparc_tls_ldm_add", "Sparc::fixup_sparc_tls_ldm_call", "Sparc::fixup_sparc_tls_ldo_hix22", "Sparc::fixup_sparc_tls_ldo_lox10", "Sparc::fixup_sparc_tls_ldo_add", "Sparc::fixup_sparc_tls_ie_hi22", "Sparc::fixup_sparc_tls_ie_lo10", "Sparc::fixup_sparc_tls_ie_ld", "Sparc::fixup_sparc_tls_ie_ldx", "Sparc::fixup_sparc_tls_ie_add", "Sparc::fixup_sparc_tls_le_hix22", "Sparc::fixup_sparc_tls_le_lox10" ]

[]

[ "<s>", "static", "tree", "s390_handle_hotpatch_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "tree", "expr", ";", "tree", "expr2", ";", "int", "err", ";", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "if", "(", "args", "!=", "NULL", "&&", "TREE_CHAIN", "(", "args", ")", "!=", "NULL", ")", "{", "expr", "=", "TREE_VALUE", "(", "args", ")", ";", "expr2", "=", "TREE_VALUE", "(", "TREE_CHAIN", "(", "args", ")", ")", ";", "}", "if", "(", "args", "==", "NULL", "||", "TREE_CHAIN", "(", "args", ")", "==", "NULL", ")", "err", "=", "1", ";", "else", "if", "(", "TREE_CODE", "(", "expr", ")", "!=", "INTEGER_CST", "||", "!", "INTEGRAL_TYPE_P", "(", "TREE_TYPE", "(", "expr", ")", ")", "||", "wi", "::", "gtu_p", "(", "expr", ",", "s390_hotpatch_hw_max", ")", ")", "err", "=", "1", ";", "else", "if", "(", "TREE_CODE", "(", "expr2", ")", "!=", "INTEGER_CST", "||", "!", "INTEGRAL_TYPE_P", "(", "TREE_TYPE", "(", "expr2", ")", ")", "||", "wi", "::", "gtu_p", "(", "expr2", ",", "s390_hotpatch_hw_max", ")", ")", "err", "=", "1", ";", "else", "err", "=", "0", ";", "if", "(", "err", ")", "{", "error", "(", "\"requested %qE attribute is not a comma separated pair of\"", "\" non-negative integer constants or too large (max. %d)\"", ",", "name", ",", "s390_hotpatch_hw_max", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Check", "whether", "the", "hotpatch", "attribute", "is", "applied", "to", "a", "function", "and", ",", "if", "it", "has", "an", "argument", ",", "the", "argument", "is", "valid", "." ]

[ "s390", "\"%qE attribute only applies to functions\"", "1", "1", "1", "0", "\"requested %qE attribute is not a comma separated pair of\"", "\" non-negative integer constants or too large (max. %d)\"" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "0", ";", "assert", "(", "TBB", "&&", "\"InsertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "3", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"RISCV branch conditions have two components!\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "MachineInstr", "&", "MI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "RISCV", "::", "PseudoBR", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "MI", ")", ";", "return", "1", ";", "}", "unsigned", "Opc", "=", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "MachineInstr", "&", "CondMI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ".", "add", "(", "Cond", "[", "2", "]", ")", ".", "addMBB", "(", "TBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "CondMI", ")", ";", "if", "(", "!", "FBB", ")", "return", "1", ";", "MachineInstr", "&", "MI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "RISCV", "::", "PseudoBR", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "MI", ")", ";", "return", "2", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "0", "\"InsertBranch must not be told to insert a fallthrough\"", "3", "0", "\"RISCV branch conditions have two components!\"", "RISCV::PseudoBR", "1", "0", "1", "2", "1", "RISCV::PseudoBR", "2" ]

[]

[ "<s>", "unsigned", "Mips16InstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "rtx", "nvptx_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", ")", "{", "if", "(", "cfun", "->", "machine", "->", "start_call", "==", "NULL_RTX", ")", "return", "gen_rtx_REG", "(", "mode", ",", "NVPTX_RETURN_REGNUM", ")", ";", "return", "gen_reg_rtx", "(", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LIBCALL_VALUE", "." ]

[ "nvptx" ]

[]

[ "<s>", "void", "avr_register_target_pragmas", "(", "void", ")", "{", "gcc_assert", "(", "ADDR_SPACE_GENERIC", "==", "ADDR_SPACE_RAM", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "ADDR_SPACE_COUNT", ";", "i", "++", ")", "{", "gcc_assert", "(", "i", "==", "avr_addrspace", "[", "i", "]", ".", "id", ")", ";", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "i", ")", ")", "c_register_addr_space", "(", "avr_addrspace", "[", "i", "]", ".", "name", ",", "avr_addrspace", "[", "i", "]", ".", "id", ")", ";", "}", "targetm", ".", "resolve_overloaded_builtin", "=", "avr_resolve_overloaded_builtin", ";", "}", "</s>" ]

[ "Implement", "`", "REGISTER_TARGET_PRAGMAS", "'", "." ]

[ "avr", "0" ]

[]

[ "<s>", "void", "GCNUpwardRPTracker", "::", "recede", "(", "const", "MachineInstr", "&", "MI", ")", "{", "assert", "(", "MRI", "&&", "\"call reset first\"", ")", ";", "LastTrackedMI", "=", "&", "MI", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "return", ";", "for", "(", "const", "auto", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isDef", "(", ")", "||", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "continue", ";", "auto", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "auto", "&", "LiveMask", "=", "LiveRegs", "[", "Reg", "]", ";", "auto", "PrevMask", "=", "LiveMask", ";", "LiveMask", "&=", "~", "getDefRegMask", "(", "MO", ")", ";", "CurPressure", ".", "inc", "(", "Reg", ",", "PrevMask", ",", "LiveMask", ",", "*", "MRI", ")", ";", "}", "for", "(", "const", "auto", "&", "MO", ":", "MI", ".", "uses", "(", ")", ")", "{", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "readsReg", "(", ")", "||", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "continue", ";", "auto", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "auto", "&", "LiveMask", "=", "LiveRegs", "[", "Reg", "]", ";", "auto", "PrevMask", "=", "LiveMask", ";", "LiveMask", "|=", "getUsedRegMask", "(", "MO", ")", ";", "CurPressure", ".", "inc", "(", "Reg", ",", "PrevMask", ",", "LiveMask", ",", "*", "MRI", ")", ";", "}", "MaxPressure", "=", "max", "(", "MaxPressure", ",", "CurPressure", ")", ";", "}", "</s>" ]

[ "Recede", "across", "the", "previous", "instruction", "." ]

[ "AMDGPU", "\"call reset first\"" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ")", "const", "{", "}", "</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", "." ]

[ "Z80" ]

[]

[ "<s>", "void", "PatmosLatencyQueue", "::", "clear", "(", ")", "{", "PendingQueue", ".", "clear", "(", ")", ";", "AvailableQueue", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "Clear", "all", "timers", "in", "this", "group", "." ]

[ "Patmos", "Patmos" ]

[]

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

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

[ "Sparc" ]

[]

[ "<s>", "SDValue", "SparcTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "bool", "hasHardQuad", "=", "Subtarget", "->", "hasHardQuad", "(", ")", ";", "bool", "is64Bit", "=", "Subtarget", "->", "is64Bit", "(", ")", ";", "bool", "isV9", "=", "Subtarget", "->", "isV9", "(", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "llvm_unreachable", "(", "\"TLS not implemented for Sparc.\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ",", "*", "this", ",", "hasHardQuad", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ",", "*", "this", ",", "hasHardQuad", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ",", "*", "this", ",", "hasHardQuad", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ",", "*", "this", ",", "hasHardQuad", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerF128Load", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerF128Store", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FADD", ":", "return", "LowerF128Op", "(", "Op", ",", "DAG", ",", "getLibcallName", "(", "RTLIB", "::", "ADD_F128", ")", ",", "2", ")", ";", "case", "ISD", "::", "FSUB", ":", "return", "LowerF128Op", "(", "Op", ",", "DAG", ",", "getLibcallName", "(", "RTLIB", "::", "SUB_F128", ")", ",", "2", ")", ";", "case", "ISD", "::", "FMUL", ":", "return", "LowerF128Op", "(", "Op", ",", "DAG", ",", "getLibcallName", "(", "RTLIB", "::", "MUL_F128", ")", ",", "2", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "LowerF128Op", "(", "Op", ",", "DAG", ",", "getLibcallName", "(", "RTLIB", "::", "DIV_F128", ")", ",", "2", ")", ";", "case", "ISD", "::", "FSQRT", ":", "return", "LowerF128Op", "(", "Op", ",", "DAG", ",", "getLibcallName", "(", "RTLIB", "::", "SQRT_F128", ")", ",", "1", ")", ";", "case", "ISD", "::", "FNEG", ":", "return", "LowerFNEG", "(", "Op", ",", "DAG", ",", "*", "this", ",", "is64Bit", ")", ";", "case", "ISD", "::", "FABS", ":", "return", "LowerFABS", "(", "Op", ",", "DAG", ",", "isV9", ")", ";", "case", "ISD", "::", "FP_EXTEND", ":", "return", "LowerF128_FPEXTEND", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "FP_ROUND", ":", "return", "LowerF128_FPROUND", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "\"Should not custom lower this!\"", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GlobalTLSAddress", "\"TLS not implemented for Sparc.\"", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::ConstantPool", "ISD::FP_TO_SINT", "ISD::SINT_TO_FP", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::VASTART", "ISD::VAARG", "ISD::DYNAMIC_STACKALLOC", "ISD::LOAD", "ISD::STORE", "ISD::FADD", "2", "ISD::FSUB", "2", "ISD::FMUL", "2", "ISD::FDIV", "2", "ISD::FSQRT", "1", "ISD::FNEG", "ISD::FABS", "ISD::FP_EXTEND", "ISD::FP_ROUND" ]

[]

[ "<s>", "static", "int", "ix86_set_reg_reg_cost", "(", "machine_mode", "mode", ")", "{", "unsigned", "int", "units", "=", "UNITS_PER_WORD", ";", "switch", "(", "GET_MODE_CLASS", "(", "mode", ")", ")", "{", "default", ":", "break", ";", "case", "MODE_CC", ":", "units", "=", "GET_MODE_SIZE", "(", "CCmode", ")", ";", "break", ";", "case", "MODE_FLOAT", ":", "if", "(", "(", "TARGET_SSE", "&&", "mode", "==", "TFmode", ")", "||", "(", "TARGET_80387", "&&", "mode", "==", "XFmode", ")", "||", "(", "(", "TARGET_80387", "||", "TARGET_SSE2", ")", "&&", "mode", "==", "DFmode", ")", "||", "(", "(", "TARGET_80387", "||", "TARGET_SSE", ")", "&&", "mode", "==", "SFmode", ")", ")", "units", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "break", ";", "case", "MODE_COMPLEX_FLOAT", ":", "if", "(", "(", "TARGET_SSE", "&&", "mode", "==", "TCmode", ")", "||", "(", "TARGET_80387", "&&", "mode", "==", "XCmode", ")", "||", "(", "(", "TARGET_80387", "||", "TARGET_SSE2", ")", "&&", "mode", "==", "DCmode", ")", "||", "(", "(", "TARGET_80387", "||", "TARGET_SSE", ")", "&&", "mode", "==", "SCmode", ")", ")", "units", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "break", ";", "case", "MODE_VECTOR_INT", ":", "case", "MODE_VECTOR_FLOAT", ":", "if", "(", "(", "TARGET_AVX512F", "&&", "VALID_AVX512F_REG_MODE", "(", "mode", ")", ")", "||", "(", "TARGET_AVX", "&&", "VALID_AVX256_REG_MODE", "(", "mode", ")", ")", "||", "(", "TARGET_SSE2", "&&", "VALID_SSE2_REG_MODE", "(", "mode", ")", ")", "||", "(", "TARGET_SSE", "&&", "VALID_SSE_REG_MODE", "(", "mode", ")", ")", "||", "(", "TARGET_MMX", "&&", "VALID_MMX_REG_MODE", "(", "mode", ")", ")", ")", "units", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "}", "return", "COSTS_N_INSNS", "(", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "units", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "moving", "between", "two", "registers", "of", "mode", "MODE", "." ]

[ "i386" ]

[]

[ "<s>", "int", "X86FrameLowering", "::", "mergeSPUpdates", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "bool", "doMergeWithPrevious", ")", "const", "{", "if", "(", "(", "doMergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "begin", "(", ")", ")", "||", "(", "!", "doMergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", ")", "return", "0", ";", "MachineBasicBlock", "::", "iterator", "PI", "=", "doMergeWithPrevious", "?", "std", "::", "prev", "(", "MBBI", ")", ":", "MBBI", ";", "MachineBasicBlock", "::", "iterator", "NI", "=", "doMergeWithPrevious", "?", "nullptr", ":", "std", "::", "next", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "int", "Offset", "=", "0", ";", "if", "(", "(", "Opc", "==", "X86", "::", "ADD64ri32", "||", "Opc", "==", "X86", "::", "ADD64ri8", "||", "Opc", "==", "X86", "::", "ADD32ri", "||", "Opc", "==", "X86", "::", "ADD32ri8", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "Offset", "+=", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "!", "doMergeWithPrevious", ")", "MBBI", "=", "NI", ";", "}", "else", "if", "(", "(", "Opc", "==", "X86", "::", "LEA32r", "||", "Opc", "==", "X86", "::", "LEA64_32r", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "Offset", "+=", "PI", "->", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", ";", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "!", "doMergeWithPrevious", ")", "MBBI", "=", "NI", ";", "}", "else", "if", "(", "(", "Opc", "==", "X86", "::", "SUB64ri32", "||", "Opc", "==", "X86", "::", "SUB64ri8", "||", "Opc", "==", "X86", "::", "SUB32ri", "||", "Opc", "==", "X86", "::", "SUB32ri8", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "Offset", "-=", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "!", "doMergeWithPrevious", ")", "MBBI", "=", "NI", ";", "}", "return", "Offset", ";", "}", "</s>" ]

[ "Check", "the", "instruction", "before/after", "the", "passed", "instruction", "." ]

[ "X86", "X86", "0", "0", "X86::ADD64ri32", "X86::ADD64ri8", "X86::ADD32ri", "X86::ADD32ri8", "0", "2", "X86::LEA32r", "X86::LEA64_32r", "0", "4", "X86::SUB64ri32", "X86::SUB64ri8", "X86::SUB32ri", "X86::SUB32ri8", "0", "2" ]

[]

[ "<s>", "bool", "X86MCInstrAnalysis", "::", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "{", "if", "(", "Inst", ".", "getNumOperands", "(", ")", "==", "0", "||", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "0", "]", ".", "OperandType", "!=", "MCOI", "::", "OPERAND_PCREL", ")", "return", "false", ";", "Target", "=", "Addr", "+", "Size", "+", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Given", "a", "branch", "instruction", "try", "to", "get", "the", "address", "the", "branch", "targets", "." ]

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

[]

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

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

[ "X86" ]

[]

[ "<s>", "bool", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "override", "{", "switch", "(", "Fixup", ".", "getTargetKind", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown Fixup Kind!\"", ")", ";", "case", "fixup_Hexagon_LO16", ":", "case", "fixup_Hexagon_HI16", ":", "case", "fixup_Hexagon_16", ":", "case", "fixup_Hexagon_8", ":", "case", "fixup_Hexagon_GPREL16_0", ":", "case", "fixup_Hexagon_GPREL16_1", ":", "case", "fixup_Hexagon_GPREL16_2", ":", "case", "fixup_Hexagon_GPREL16_3", ":", "case", "fixup_Hexagon_HL16", ":", "case", "fixup_Hexagon_32_6_X", ":", "case", "fixup_Hexagon_16_X", ":", "case", "fixup_Hexagon_12_X", ":", "case", "fixup_Hexagon_11_X", ":", "case", "fixup_Hexagon_10_X", ":", "case", "fixup_Hexagon_9_X", ":", "case", "fixup_Hexagon_8_X", ":", "case", "fixup_Hexagon_7_X", ":", "case", "fixup_Hexagon_6_X", ":", "case", "fixup_Hexagon_COPY", ":", "case", "fixup_Hexagon_GLOB_DAT", ":", "case", "fixup_Hexagon_JMP_SLOT", ":", "case", "fixup_Hexagon_RELATIVE", ":", "case", "fixup_Hexagon_PLT_B22_PCREL", ":", "case", "fixup_Hexagon_GOTREL_LO16", ":", "case", "fixup_Hexagon_GOTREL_HI16", ":", "case", "fixup_Hexagon_GOTREL_32", ":", "case", "fixup_Hexagon_GOT_LO16", ":", "case", "fixup_Hexagon_GOT_HI16", ":", "case", "fixup_Hexagon_GOT_32", ":", "case", "fixup_Hexagon_GOT_16", ":", "case", "fixup_Hexagon_DTPMOD_32", ":", "case", "fixup_Hexagon_DTPREL_LO16", ":", "case", "fixup_Hexagon_DTPREL_HI16", ":", "case", "fixup_Hexagon_DTPREL_32", ":", "case", "fixup_Hexagon_DTPREL_16", ":", "case", "fixup_Hexagon_GD_PLT_B22_PCREL", ":", "case", "fixup_Hexagon_LD_PLT_B22_PCREL", ":", "case", "fixup_Hexagon_GD_GOT_LO16", ":", "case", "fixup_Hexagon_GD_GOT_HI16", ":", "case", "fixup_Hexagon_GD_GOT_32", ":", "case", "fixup_Hexagon_GD_GOT_16", ":", "case", "fixup_Hexagon_LD_GOT_LO16", ":", "case", "fixup_Hexagon_LD_GOT_HI16", ":", "case", "fixup_Hexagon_LD_GOT_32", ":", "case", "fixup_Hexagon_LD_GOT_16", ":", "case", "fixup_Hexagon_IE_LO16", ":", "case", "fixup_Hexagon_IE_HI16", ":", "case", "fixup_Hexagon_IE_32", ":", "case", "fixup_Hexagon_IE_16", ":", "case", "fixup_Hexagon_IE_GOT_LO16", ":", "case", "fixup_Hexagon_IE_GOT_HI16", ":", "case", "fixup_Hexagon_IE_GOT_32", ":", "case", "fixup_Hexagon_IE_GOT_16", ":", "case", "fixup_Hexagon_TPREL_LO16", ":", "case", "fixup_Hexagon_TPREL_HI16", ":", "case", "fixup_Hexagon_TPREL_32", ":", "case", "fixup_Hexagon_TPREL_16", ":", "case", "fixup_Hexagon_GOTREL_32_6_X", ":", "case", "fixup_Hexagon_GOTREL_16_X", ":", "case", "fixup_Hexagon_GOTREL_11_X", ":", "case", "fixup_Hexagon_GOT_32_6_X", ":", "case", "fixup_Hexagon_GOT_16_X", ":", "case", "fixup_Hexagon_GOT_11_X", ":", "case", "fixup_Hexagon_DTPREL_32_6_X", ":", "case", "fixup_Hexagon_DTPREL_16_X", ":", "case", "fixup_Hexagon_DTPREL_11_X", ":", "case", "fixup_Hexagon_GD_GOT_32_6_X", ":", "case", "fixup_Hexagon_GD_GOT_16_X", ":", "case", "fixup_Hexagon_GD_GOT_11_X", ":", "case", "fixup_Hexagon_LD_GOT_32_6_X", ":", "case", "fixup_Hexagon_LD_GOT_16_X", ":", "case", "fixup_Hexagon_LD_GOT_11_X", ":", "case", "fixup_Hexagon_IE_32_6_X", ":", "case", "fixup_Hexagon_IE_16_X", ":", "case", "fixup_Hexagon_IE_GOT_32_6_X", ":", "case", "fixup_Hexagon_IE_GOT_16_X", ":", "case", "fixup_Hexagon_IE_GOT_11_X", ":", "case", "fixup_Hexagon_TPREL_32_6_X", ":", "case", "fixup_Hexagon_TPREL_16_X", ":", "case", "fixup_Hexagon_TPREL_11_X", ":", "case", "fixup_Hexagon_32_PCREL", ":", "case", "fixup_Hexagon_6_PCREL_X", ":", "case", "fixup_Hexagon_23_REG", ":", "case", "fixup_Hexagon_27_REG", ":", "case", "fixup_Hexagon_GD_PLT_B22_PCREL_X", ":", "case", "fixup_Hexagon_GD_PLT_B32_PCREL_X", ":", "case", "fixup_Hexagon_LD_PLT_B22_PCREL_X", ":", "case", "fixup_Hexagon_LD_PLT_B32_PCREL_X", ":", "return", "true", ";", "case", "fixup_Hexagon_B22_PCREL", ":", "break", ";", "case", "fixup_Hexagon_B13_PCREL", ":", "case", "fixup_Hexagon_B13_PCREL_X", ":", "case", "fixup_Hexagon_B32_PCREL_X", ":", "case", "fixup_Hexagon_B22_PCREL_X", ":", "case", "fixup_Hexagon_B15_PCREL", ":", "case", "fixup_Hexagon_B15_PCREL_X", ":", "case", "fixup_Hexagon_B9_PCREL", ":", "case", "fixup_Hexagon_B9_PCREL_X", ":", "case", "fixup_Hexagon_B7_PCREL", ":", "case", "fixup_Hexagon_B7_PCREL_X", ":", "if", "(", "DisableFixup", ")", "return", "true", ";", "break", ";", "case", "FK_Data_1", ":", "case", "FK_Data_2", ":", "case", "FK_Data_4", ":", "case", "FK_PCRel_4", ":", "case", "fixup_Hexagon_32", ":", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Hook", "to", "check", "if", "a", "relocation", "is", "needed", "for", "some", "target", "specific", "reason", "." ]

[ "Hexagon", "\"Unknown Fixup Kind!\"", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "HSAILTargetMachine", "::", "addPassesToEmitFile", "(", "PassManagerBase", "&", "PM", ",", "raw_pwrite_stream", "&", "Out", ",", "CodeGenFileType", "FT", ",", "bool", "DisableVerify", ",", "AnalysisID", "StartBefore", ",", "AnalysisID", "StartAfter", ",", "AnalysisID", "StopAfter", ",", "MachineFunctionInitializer", "*", "MFInitializer", ")", "{", "return", "LLVMTargetMachine", "::", "addPassesToEmitFile", "(", "PM", ",", "Out", ",", "FT", ",", "DisableVerify", ",", "StartAfter", ",", "StopAfter", ",", "MFInitializer", ")", ";", "}", "</s>" ]

[ "Add", "passes", "to", "the", "specified", "pass", "manager", "to", "get", "the", "specified", "file", "emitted", "." ]

[ "HSAIL", "HSAIL" ]

[]

[ "<s>", "void", "Thumb1InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "assert", "(", "(", "RC", "==", "&", "ARM", "::", "tGPRRegClass", "||", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "DestReg", ")", "&&", "isARMLowRegister", "(", "DestReg", ")", ")", ")", "&&", "\"Unknown regclass!\"", ")", ";", "if", "(", "RC", "==", "&", "ARM", "::", "tGPRRegClass", "||", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "DestReg", ")", "&&", "isARMLowRegister", "(", "DestReg", ")", ")", ")", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tLDRspi", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM::tGPRRegClass", "ARM", "\"Unknown regclass!\"", "ARM::tGPRRegClass", "ARM", "ARM::tLDRspi", "0" ]

[]

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

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

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

[]

[ "<s>", "SDValue", "VETargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "TRUNCATE", ":", "return", "combineTRUNCATE", "(", "N", ",", "DCI", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "VE", "VE", "ISD::TRUNCATE" ]

[]

[ "<s>", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "AMDGPUTargetLowering", "::", "splitVector", "(", "const", "SDValue", "&", "N", ",", "const", "SDLoc", "&", "DL", ",", "const", "EVT", "&", "LoVT", ",", "const", "EVT", "&", "HiVT", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "assert", "(", "LoVT", ".", "getVectorNumElements", "(", ")", "+", "(", "HiVT", ".", "isVector", "(", ")", "?", "HiVT", ".", "getVectorNumElements", "(", ")", ":", "1", ")", "<=", "N", ".", "getValueType", "(", ")", ".", "getVectorNumElements", "(", ")", "&&", "\"More vector elements requested than available!\"", ")", ";", "SDValue", "Lo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "LoVT", ",", "N", ",", "DAG", ".", "getVectorIdxConstant", "(", "0", ",", "DL", ")", ")", ";", "SDValue", "Hi", "=", "DAG", ".", "getNode", "(", "HiVT", ".", "isVector", "(", ")", "?", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "DL", ",", "HiVT", ",", "N", ",", "DAG", ".", "getVectorIdxConstant", "(", "LoVT", ".", "getVectorNumElements", "(", ")", ",", "DL", ")", ")", ";", "return", "std", "::", "make_pair", "(", "Lo", ",", "Hi", ")", ";", "}", "</s>" ]

[ "Split", "a", "vector", "value", "into", "two", "parts", "of", "types", "LoVT", "and", "HiVT", "." ]

[ "AMDGPU", "AMDGPU", "1", "\"More vector elements requested than available!\"", "ISD::EXTRACT_SUBVECTOR", "0", "ISD::EXTRACT_SUBVECTOR", "ISD::EXTRACT_VECTOR_ELT" ]

[]

[ "<s>", "unsigned", "X86RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "int", "AMDGPUInstrInfo", "::", "pseudoToMCOpcode", "(", "int", "Opcode", ")", "const", "{", "int", "MCOp", "=", "AMDGPU", "::", "getMCOpcode", "(", "Opcode", ",", "AMDGPUSubtargetToSISubtarget", "(", "ST", ".", "getGeneration", "(", ")", ")", ")", ";", "if", "(", "MCOp", "==", "-", "1", ")", "return", "Opcode", ";", "if", "(", "MCOp", "==", "(", "uint16_t", ")", "-", "1", ")", "return", "-", "1", ";", "return", "MCOp", ";", "}", "</s>" ]

[ "Return", "a", "target-specific", "opcode", "if", "Opcode", "is", "a", "pseudo", "instruction", "." ]

[ "R600", "SI", "1", "1", "1" ]

[]

[ "<s>", "bool", "AMDGPUInstructionSelector", "::", "select", "(", "MachineInstr", "&", "I", ")", "{", "if", "(", "I", ".", "isPHI", "(", ")", ")", "return", "selectPHI", "(", "I", ")", ";", "if", "(", "!", "isPreISelGenericOpcode", "(", "I", ".", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "I", ".", "isCopy", "(", ")", ")", "return", "selectCOPY", "(", "I", ")", ";", "return", "true", ";", "}", "switch", "(", "I", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_AND", ":", "case", "TargetOpcode", "::", "G_OR", ":", "case", "TargetOpcode", "::", "G_XOR", ":", "if", "(", "selectG_AND_OR_XOR", "(", "I", ")", ")", "return", "true", ";", "return", "selectImpl", "(", "I", ",", "*", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_ADD", ":", "case", "TargetOpcode", "::", "G_SUB", ":", "if", "(", "selectG_ADD_SUB", "(", "I", ")", ")", "return", "true", ";", "LLVM_FALLTHROUGH", ";", "default", ":", "return", "selectImpl", "(", "I", ",", "*", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_INTTOPTR", ":", "case", "TargetOpcode", "::", "G_BITCAST", ":", "return", "selectCOPY", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_CONSTANT", ":", "case", "TargetOpcode", "::", "G_FCONSTANT", ":", "return", "selectG_CONSTANT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_EXTRACT", ":", "return", "selectG_EXTRACT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_MERGE_VALUES", ":", "case", "TargetOpcode", "::", "G_BUILD_VECTOR", ":", "case", "TargetOpcode", "::", "G_CONCAT_VECTORS", ":", "return", "selectG_MERGE_VALUES", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_UNMERGE_VALUES", ":", "return", "selectG_UNMERGE_VALUES", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_GEP", ":", "return", "selectG_GEP", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_IMPLICIT_DEF", ":", "return", "selectG_IMPLICIT_DEF", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_INSERT", ":", "return", "selectG_INSERT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC", ":", "return", "selectG_INTRINSIC", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC_W_SIDE_EFFECTS", ":", "return", "selectG_INTRINSIC_W_SIDE_EFFECTS", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_ICMP", ":", "if", "(", "selectG_ICMP", "(", "I", ")", ")", "return", "true", ";", "return", "selectImpl", "(", "I", ",", "*", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "case", "TargetOpcode", "::", "G_ATOMIC_CMPXCHG", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_XCHG", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_ADD", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_SUB", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_AND", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_OR", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_XOR", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_MIN", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_MAX", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_UMIN", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_UMAX", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_FADD", ":", "return", "selectG_LOAD_ATOMICRMW", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_SELECT", ":", "return", "selectG_SELECT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_STORE", ":", "return", "selectG_STORE", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_TRUNC", ":", "return", "selectG_TRUNC", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_SEXT", ":", "case", "TargetOpcode", "::", "G_ZEXT", ":", "case", "TargetOpcode", "::", "G_ANYEXT", ":", "return", "selectG_SZA_EXT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_BRCOND", ":", "return", "selectG_BRCOND", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_FRAME_INDEX", ":", "return", "selectG_FRAME_INDEX", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_FENCE", ":", "I", ".", "setDesc", "(", "TII", ".", "get", "(", "AMDGPU", "::", "ATOMIC_FENCE", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Select", "the", "(", "possibly", "generic", ")", "instruction", "I", "to", "only", "use", "target-specific", "opcodes", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SI", "SI", "SI", "AMDGPU::ATOMIC_FENCE" ]

[]

[ "<s>", "static", "tree", "fold_build_vec_cmp", "(", "tree_code", "code", ",", "tree", "type", ",", "tree", "arg0", ",", "tree", "arg1", ",", "gimple_stmt_iterator", "*", "gsi", ")", "{", "tree", "cmp_type", "=", "truth_type_for", "(", "type", ")", ";", "tree", "zero_vec", "=", "build_zero_cst", "(", "type", ")", ";", "tree", "minus_one_vec", "=", "build_minus_one_cst", "(", "type", ")", ";", "tree", "temp", "=", "create_tmp_reg_or_ssa_name", "(", "cmp_type", ")", ";", "gimple", "*", "g", "=", "gimple_build_assign", "(", "temp", ",", "code", ",", "arg0", ",", "arg1", ")", ";", "gsi_insert_before", "(", "gsi", ",", "g", ",", "GSI_SAME_STMT", ")", ";", "return", "fold_build3", "(", "VEC_COND_EXPR", ",", "type", ",", "temp", ",", "minus_one_vec", ",", "zero_vec", ")", ";", "}", "</s>" ]

[ "Helper", "function", "to", "handle", "the", "gimple", "folding", "of", "a", "vector", "compare", "operation", ".", "This", "sets", "up", "true/false", "vectors", ",", "and", "uses", "the", "VEC_COND_EXPR", "operation", ".", "CODE", "indicates", "which", "comparison", "is", "to", "be", "made", ".", "(", "EQ", ",", "GT", ",", "...", ")", ".", "TYPE", "indicates", "the", "type", "of", "the", "result", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "ARMAsmBackend", "::", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "MCInst", "&", "Res", ")", "const", "{", "unsigned", "RelaxedOp", "=", "getRelaxedOpcode", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "RelaxedOp", "==", "Inst", ".", "getOpcode", "(", ")", ")", "{", "SmallString", "<", "256", ">", "Tmp", ";", "raw_svector_ostream", "OS", "(", "Tmp", ")", ";", "Inst", ".", "dump_pretty", "(", "OS", ")", ";", "OS", "<<", "\"\\n\"", ";", "report_fatal_error", "(", "\"unexpected instruction to relax: \"", "+", "OS", ".", "str", "(", ")", ")", ";", "}", "if", "(", "(", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tCBZ", "||", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tCBNZ", ")", "&&", "RelaxedOp", "==", "ARM", "::", "tHINT", ")", "{", "Res", ".", "setOpcode", "(", "RelaxedOp", ")", ";", "Res", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "0", ")", ")", ";", "Res", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "14", ")", ")", ";", "Res", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "0", ")", ")", ";", "return", ";", "}", "Res", "=", "Inst", ";", "Res", ".", "setOpcode", "(", "RelaxedOp", ")", ";", "}", "</s>" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

[ "ARM", "ARM", "256", "\"\\n\"", "\"unexpected instruction to relax: \"", "ARM::tCBZ", "ARM::tCBNZ", "ARM::tHINT", "0", "14", "0" ]

[]

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

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

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

[]

[ "<s>", "BitVector", "SparcRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G1", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G2", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G3", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G4", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "O6", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "I6", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "I7", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G0", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G5", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G6", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G7", ")", ";", "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::O6", "SP::I6", "SP::I7", "SP::G0", "SP::G5", "SP::G6", "SP::G7" ]

[]

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

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

[ "Cpu0", "Cpu0::NumTargetFixupKinds" ]

[]

[ "<s>", "static", "void", "handle_special_swappables", "(", "swap_web_entry", "*", "insn_entry", ",", "unsigned", "i", ")", "{", "rtx_insn", "*", "insn", "=", "insn_entry", "[", "i", "]", ".", "insn", ";", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "switch", "(", "insn_entry", "[", "i", "]", ".", "special_handling", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "SH_CONST_VECTOR", ":", "{", "gcc_assert", "(", "GET_CODE", "(", "body", ")", "==", "SET", ")", ";", "rtx", "rhs", "=", "SET_SRC", "(", "body", ")", ";", "swap_const_vector_halves", "(", "rhs", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Swapping constant halves in insn %d\\n\"", ",", "i", ")", ";", "break", ";", "}", "case", "SH_SUBREG", ":", "adjust_subreg_index", "(", "body", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Adjusting subreg in insn %d\\n\"", ",", "i", ")", ";", "break", ";", "case", "SH_NOSWAP_LD", ":", "permute_load", "(", "insn", ")", ";", "break", ";", "case", "SH_NOSWAP_ST", ":", "permute_store", "(", "insn", ")", ";", "break", ";", "case", "SH_EXTRACT", ":", "adjust_extract", "(", "insn", ")", ";", "break", ";", "case", "SH_SPLAT", ":", "adjust_splat", "(", "insn", ")", ";", "break", ";", "case", "SH_XXPERMDI", ":", "adjust_xxpermdi", "(", "insn", ")", ";", "break", ";", "case", "SH_CONCAT", ":", "adjust_concat", "(", "insn", ")", ";", "break", ";", "case", "SH_VPERM", ":", "adjust_vperm", "(", "insn", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "The", "insn", "described", "by", "INSN_ENTRY", "[", "I", "]", "can", "be", "swapped", ",", "but", "only", "with", "special", "handling", ".", "Take", "care", "of", "that", "here", "." ]

[ "rs6000", "\"Swapping constant halves in insn %d\\n\"", "\"Adjusting subreg in insn %d\\n\"" ]

[]

[ "<s>", "static", "rtx", "altivec_expand_vec_init_builtin", "(", "tree", "type", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "machine_mode", "tmode", "=", "TYPE_MODE", "(", "type", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "tmode", ")", ";", "int", "i", ",", "n_elt", "=", "GET_MODE_NUNITS", "(", "tmode", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "tmode", ")", ")", ";", "gcc_assert", "(", "n_elt", "==", "call_expr_nargs", "(", "exp", ")", ")", ";", "if", "(", "!", "target", "||", "!", "register_operand", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "if", "(", "n_elt", "==", "1", "&&", "GET_MODE_SIZE", "(", "tmode", ")", "==", "GET_MODE_SIZE", "(", "inner_mode", ")", ")", "{", "rtx", "x", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ")", ";", "emit_move_insn", "(", "target", ",", "gen_lowpart", "(", "tmode", ",", "x", ")", ")", ";", "}", "else", "{", "rtvec", "v", "=", "rtvec_alloc", "(", "n_elt", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elt", ";", "++", "i", ")", "{", "rtx", "x", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "i", ")", ")", ";", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "gen_lowpart", "(", "inner_mode", ",", "x", ")", ";", "}", "rs6000_expand_vector_init", "(", "target", ",", "gen_rtx_PARALLEL", "(", "tmode", ",", "v", ")", ")", ";", "}", "return", "target", ";", "}", "</s>" ]

[ "Expand", "vec_init", "builtin", "." ]

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

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isShuffleMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "M", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "if", "(", "VT", ".", "getScalarType", "(", ")", "==", "MVT", "::", "i1", ")", "return", "false", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "false", ";", "return", "isTypeLegal", "(", "VT", ".", "getSimpleVT", "(", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "MVT::i1", "64" ]

[]

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

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

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

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isHighLatencyDef", "(", "int", "opc", ")", "const", "{", "switch", "(", "opc", ")", "{", "default", ":", "return", "false", ";", "case", "X86", "::", "DIVSDrm", ":", "case", "X86", "::", "DIVSDrm_Int", ":", "case", "X86", "::", "DIVSDrr", ":", "case", "X86", "::", "DIVSDrr_Int", ":", "case", "X86", "::", "DIVSSrm", ":", "case", "X86", "::", "DIVSSrm_Int", ":", "case", "X86", "::", "DIVSSrr", ":", "case", "X86", "::", "DIVSSrr_Int", ":", "case", "X86", "::", "SQRTPDm", ":", "case", "X86", "::", "SQRTPDm_Int", ":", "case", "X86", "::", "SQRTPDr", ":", "case", "X86", "::", "SQRTPDr_Int", ":", "case", "X86", "::", "SQRTPSm", ":", "case", "X86", "::", "SQRTPSm_Int", ":", "case", "X86", "::", "SQRTPSr", ":", "case", "X86", "::", "SQRTPSr_Int", ":", "case", "X86", "::", "SQRTSDm", ":", "case", "X86", "::", "SQRTSDm_Int", ":", "case", "X86", "::", "SQRTSDr", ":", "case", "X86", "::", "SQRTSDr_Int", ":", "case", "X86", "::", "SQRTSSm", ":", "case", "X86", "::", "SQRTSSm_Int", ":", "case", "X86", "::", "SQRTSSr", ":", "case", "X86", "::", "SQRTSSr_Int", ":", "case", "X86", "::", "VDIVSDrm", ":", "case", "X86", "::", "VDIVSDrm_Int", ":", "case", "X86", "::", "VDIVSDrr", ":", "case", "X86", "::", "VDIVSDrr_Int", ":", "case", "X86", "::", "VDIVSSrm", ":", "case", "X86", "::", "VDIVSSrm_Int", ":", "case", "X86", "::", "VDIVSSrr", ":", "case", "X86", "::", "VDIVSSrr_Int", ":", "case", "X86", "::", "VSQRTPDm", ":", "case", "X86", "::", "VSQRTPDm_Int", ":", "case", "X86", "::", "VSQRTPDr", ":", "case", "X86", "::", "VSQRTPDr_Int", ":", "case", "X86", "::", "VSQRTPSm", ":", "case", "X86", "::", "VSQRTPSm_Int", ":", "case", "X86", "::", "VSQRTPSr", ":", "case", "X86", "::", "VSQRTPSr_Int", ":", "case", "X86", "::", "VSQRTSDm", ":", "case", "X86", "::", "VSQRTSDm_Int", ":", "case", "X86", "::", "VSQRTSDr", ":", "case", "X86", "::", "VSQRTSSm", ":", "case", "X86", "::", "VSQRTSSm_Int", ":", "case", "X86", "::", "VSQRTSSr", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "this", "opcode", "has", "high", "latency", "to", "its", "result", "." ]

[ "X86", "X86", "X86::DIVSDrm", "X86::DIVSDrm_Int", "X86::DIVSDrr", "X86::DIVSDrr_Int", "X86::DIVSSrm", "X86::DIVSSrm_Int", "X86::DIVSSrr", "X86::DIVSSrr_Int", "X86::SQRTPDm", "X86::SQRTPDm_Int", "X86::SQRTPDr", "X86::SQRTPDr_Int", "X86::SQRTPSm", "X86::SQRTPSm_Int", "X86::SQRTPSr", "X86::SQRTPSr_Int", "X86::SQRTSDm", "X86::SQRTSDm_Int", "X86::SQRTSDr", "X86::SQRTSDr_Int", "X86::SQRTSSm", "X86::SQRTSSm_Int", "X86::SQRTSSr", "X86::SQRTSSr_Int", "X86::VDIVSDrm", "X86::VDIVSDrm_Int", "X86::VDIVSDrr", "X86::VDIVSDrr_Int", "X86::VDIVSSrm", "X86::VDIVSSrm_Int", "X86::VDIVSSrr", "X86::VDIVSSrr_Int", "X86::VSQRTPDm", "X86::VSQRTPDm_Int", "X86::VSQRTPDr", "X86::VSQRTPDr_Int", "X86::VSQRTPSm", "X86::VSQRTPSm_Int", "X86::VSQRTPSr", "X86::VSQRTPSr_Int", "X86::VSQRTSDm", "X86::VSQRTSDm_Int", "X86::VSQRTSDr", "X86::VSQRTSSm", "X86::VSQRTSSm_Int", "X86::VSQRTSSr" ]

[]

[ "<s>", "MachineBasicBlock", "*", "Cpu0TargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "Cpu0", "::", "ATOMIC_LOAD_ADD_I8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "1", ",", "Cpu0", "::", "ADDu", ")", ";", "case", "Cpu0", "::", "ATOMIC_LOAD_ADD_I16", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "2", ",", "Cpu0", "::", "ADDu", ")", ";", "case", "Cpu0", "::", "ATOMIC_LOAD_ADD_I32", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "4", ",", "Cpu0", "::", "ADDu", ")", ";", "case", "Cpu0", "::", "ATOMIC_LOAD_AND_I8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "1", ",", "Cpu0", "::", "AND", ")", ";", "case", "Cpu0", "::", "ATOMIC_LOAD_AND_I16", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "2", ",", "Cpu0", "::", "AND", ")", ";", "case", "Cpu0", "::", "ATOMIC_LOAD_AND_I32", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "4", ",", "Cpu0", "::", "AND", ")", ";", "case", "Cpu0", "::", "ATOMIC_LOAD_OR_I8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "1", ",", "Cpu0", "::", "OR", ")", ";", "case", "Cpu0", "::", "ATOMIC_LOAD_OR_I16", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "2", ",", "Cpu0", "::", "OR", ")", ";", "case", "Cpu0", "::", "ATOMIC_LOAD_OR_I32", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "4", ",", "Cpu0", "::", "OR", ")", ";", "case", "Cpu0", "::", "ATOMIC_LOAD_XOR_I8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "1", ",", "Cpu0", "::", "XOR", ")", ";", "case", "Cpu0", "::", "ATOMIC_LOAD_XOR_I16", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "2", ",", "Cpu0", "::", "XOR", ")", ";", "case", "Cpu0", "::", "ATOMIC_LOAD_XOR_I32", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "4", ",", "Cpu0", "::", "XOR", ")", ";", "case", "Cpu0", "::", "ATOMIC_LOAD_NAND_I8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "1", ",", "0", ",", "true", ")", ";", "case", "Cpu0", "::", "ATOMIC_LOAD_NAND_I16", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "2", ",", "0", ",", "true", ")", ";", "case", "Cpu0", "::", "ATOMIC_LOAD_NAND_I32", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "4", ",", "0", ",", "true", ")", ";", "case", "Cpu0", "::", "ATOMIC_LOAD_SUB_I8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "1", ",", "Cpu0", "::", "SUBu", ")", ";", "case", "Cpu0", "::", "ATOMIC_LOAD_SUB_I16", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "2", ",", "Cpu0", "::", "SUBu", ")", ";", "case", "Cpu0", "::", "ATOMIC_LOAD_SUB_I32", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "4", ",", "Cpu0", "::", "SUBu", ")", ";", "case", "Cpu0", "::", "ATOMIC_SWAP_I8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "1", ",", "0", ")", ";", "case", "Cpu0", "::", "ATOMIC_SWAP_I16", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "2", ",", "0", ")", ";", "case", "Cpu0", "::", "ATOMIC_SWAP_I32", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "4", ",", "0", ")", ";", "case", "Cpu0", "::", "ATOMIC_CMP_SWAP_I8", ":", "return", "emitAtomicCmpSwapPartword", "(", "MI", ",", "BB", ",", "1", ")", ";", "case", "Cpu0", "::", "ATOMIC_CMP_SWAP_I16", ":", "return", "emitAtomicCmpSwapPartword", "(", "MI", ",", "BB", ",", "2", ")", ";", "case", "Cpu0", "::", "ATOMIC_CMP_SWAP_I32", ":", "return", "emitAtomicCmpSwap", "(", "MI", ",", "BB", ",", "4", ")", ";", "}", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "\"Unexpected instr type to insert\"", "Cpu0::ATOMIC_LOAD_ADD_I8", "1", "Cpu0::ADDu", "Cpu0::ATOMIC_LOAD_ADD_I16", "2", "Cpu0::ADDu", "Cpu0::ATOMIC_LOAD_ADD_I32", "4", "Cpu0::ADDu", "Cpu0::ATOMIC_LOAD_AND_I8", "1", "Cpu0::AND", "Cpu0::ATOMIC_LOAD_AND_I16", "2", "Cpu0::AND", "Cpu0::ATOMIC_LOAD_AND_I32", "4", "Cpu0::AND", "Cpu0::ATOMIC_LOAD_OR_I8", "1", "Cpu0::OR", "Cpu0::ATOMIC_LOAD_OR_I16", "2", "Cpu0::OR", "Cpu0::ATOMIC_LOAD_OR_I32", "4", "Cpu0::OR", "Cpu0::ATOMIC_LOAD_XOR_I8", "1", "Cpu0::XOR", "Cpu0::ATOMIC_LOAD_XOR_I16", "2", "Cpu0::XOR", "Cpu0::ATOMIC_LOAD_XOR_I32", "4", "Cpu0::XOR", "Cpu0::ATOMIC_LOAD_NAND_I8", "1", "0", "Cpu0::ATOMIC_LOAD_NAND_I16", "2", "0", "Cpu0::ATOMIC_LOAD_NAND_I32", "4", "0", "Cpu0::ATOMIC_LOAD_SUB_I8", "1", "Cpu0::SUBu", "Cpu0::ATOMIC_LOAD_SUB_I16", "2", "Cpu0::SUBu", "Cpu0::ATOMIC_LOAD_SUB_I32", "4", "Cpu0::SUBu", "Cpu0::ATOMIC_SWAP_I8", "1", "0", "Cpu0::ATOMIC_SWAP_I16", "2", "0", "Cpu0::ATOMIC_SWAP_I32", "4", "0", "Cpu0::ATOMIC_CMP_SWAP_I8", "1", "Cpu0::ATOMIC_CMP_SWAP_I16", "2", "Cpu0::ATOMIC_CMP_SWAP_I32", "4" ]

[]

[ "<s>", "static", "bool", "aarch64_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_SIMD", "&&", "(", "mode", "==", "V4SImode", "||", "mode", "==", "V8HImode", "||", "mode", "==", "V16QImode", "||", "mode", "==", "V2DImode", "||", "mode", "==", "V2SImode", "||", "mode", "==", "V4HImode", "||", "mode", "==", "V8QImode", "||", "mode", "==", "V2SFmode", "||", "mode", "==", "V4SFmode", "||", "mode", "==", "V2DFmode", "||", "mode", "==", "V4HFmode", "||", "mode", "==", "V8HFmode", "||", "mode", "==", "V1DFmode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implements", "target", "hook", "vector_mode_supported_p", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "R600AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MF", ".", "ensureAlignment", "(", "Align", "(", "256", ")", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "MCContext", "&", "Context", "=", "getObjFileLowering", "(", ")", ".", "getContext", "(", ")", ";", "MCSectionELF", "*", "ConfigSection", "=", "Context", ".", "getELFSection", "(", "\".AMDGPU.config\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "0", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "ConfigSection", ")", ";", "EmitProgramInfoR600", "(", "MF", ")", ";", "EmitFunctionBody", "(", ")", ";", "if", "(", "isVerbose", "(", ")", ")", "{", "MCSectionELF", "*", "CommentSection", "=", "Context", ".", "getELFSection", "(", "\".AMDGPU.csdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "0", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "CommentSection", ")", ";", "R600MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "R600MachineFunctionInfo", ">", "(", ")", ";", "OutStreamer", "->", "emitRawComment", "(", "Twine", "(", "\"SQ_PGM_RESOURCES:STACK_SIZE = \"", "+", "Twine", "(", "MFI", "->", "CFStackSize", ")", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "256", "\".AMDGPU.config\"", "0", "R600", "\".AMDGPU.csdata\"", "0", "R600", "R600", "\"SQ_PGM_RESOURCES:STACK_SIZE = \"" ]

[]

[ "<s>", "static", "void", "visium_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "static_chain", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "rtx", "addr", "=", "XEXP", "(", "m_tramp", ",", "0", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "addr", ",", "0", ")", ")", ",", "plus_constant", "(", "SImode", ",", "expand_shift", "(", "RSHIFT_EXPR", ",", "SImode", ",", "fnaddr", ",", "16", ",", "NULL_RTX", ",", "1", ")", ",", "0x04a90000", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "addr", ",", "4", ")", ")", ",", "plus_constant", "(", "SImode", ",", "expand_and", "(", "SImode", ",", "fnaddr", ",", "GEN_INT", "(", "0xffff", ")", ",", "NULL_RTX", ")", ",", "0x04890000", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "addr", ",", "8", ")", ")", ",", "plus_constant", "(", "SImode", ",", "expand_shift", "(", "RSHIFT_EXPR", ",", "SImode", ",", "static_chain", ",", "16", ",", "NULL_RTX", ",", "1", ")", ",", "0x04b40000", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "addr", ",", "12", ")", ")", ",", "gen_int_mode", "(", "0xff892404", ",", "SImode", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "addr", ",", "16", ")", ")", ",", "plus_constant", "(", "SImode", ",", "expand_and", "(", "SImode", ",", "static_chain", ",", "GEN_INT", "(", "0xffff", ")", ",", "NULL_RTX", ")", ",", "0x04940000", ")", ")", ";", "emit_library_call", "(", "set_trampoline_parity_libfunc", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "1", ",", "addr", ",", "SImode", ")", ";", "}", "</s>" ]

[ "Initialize", "a", "trampoline", ".", "M_TRAMP", "is", "an", "RTX", "for", "the", "memory", "block", "for", "the", "trampoline", ",", "FNDECL", "is", "the", "FUNCTION_DECL", "for", "the", "nested", "function", "and", "STATIC_CHAIN", "is", "an", "RTX", "for", "the", "static", "chain", "value", "that", "should", "be", "passed", "to", "the", "function", "when", "it", "is", "called", "." ]

[ "visium", "0", "0", "0", "16", "1", "0x04a90000", "4", "0xffff", "0x04890000", "8", "16", "1", "0x04b40000", "12", "0xff892404", "16", "0xffff", "0x04940000", "1" ]

[]

[ "<s>", "inline", "static", "int", "number_of_first_bit_set", "(", "unsigned", "mask", ")", "{", "return", "ctz_hwi", "(", "mask", ")", ";", "}", "</s>" ]

[ "Return", "the", "number", "(", "counting", "from", "0", ")", "of", "the", "least", "significant", "set", "bit", "in", "MASK", "." ]

[ "arm" ]

[]

[ "<s>", "int", "num_insns_constant", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "HOST_WIDE_INT", "low", ",", "high", ";", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "CONST_INT", ":", "if", "(", "(", "INTVAL", "(", "op", ")", ">>", "31", ")", "!=", "0", "&&", "(", "INTVAL", "(", "op", ")", ">>", "31", ")", "!=", "-", "1", "&&", "mask64_operand", "(", "op", ",", "mode", ")", ")", "return", "2", ";", "else", "return", "num_insns_constant_wide", "(", "INTVAL", "(", "op", ")", ")", ";", "case", "CONST_DOUBLE", ":", "if", "(", "mode", "==", "SFmode", ")", "{", "long", "l", ";", "REAL_VALUE_TYPE", "rv", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "rv", ",", "op", ")", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "rv", ",", "l", ")", ";", "return", "num_insns_constant_wide", "(", "(", "HOST_WIDE_INT", ")", "l", ")", ";", "}", "if", "(", "mode", "==", "VOIDmode", "||", "mode", "==", "DImode", ")", "{", "high", "=", "CONST_DOUBLE_HIGH", "(", "op", ")", ";", "low", "=", "CONST_DOUBLE_LOW", "(", "op", ")", ";", "}", "else", "{", "long", "l", "[", "2", "]", ";", "REAL_VALUE_TYPE", "rv", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "rv", ",", "op", ")", ";", "REAL_VALUE_TO_TARGET_DOUBLE", "(", "rv", ",", "l", ")", ";", "high", "=", "l", "[", "WORDS_BIG_ENDIAN", "==", "0", "]", ";", "low", "=", "l", "[", "WORDS_BIG_ENDIAN", "!=", "0", "]", ";", "}", "if", "(", "TARGET_32BIT", ")", "return", "(", "num_insns_constant_wide", "(", "low", ")", "+", "num_insns_constant_wide", "(", "high", ")", ")", ";", "else", "{", "if", "(", "(", "high", "==", "0", "&&", "low", ">=", "0", ")", "||", "(", "high", "==", "-", "1", "&&", "low", "<", "0", ")", ")", "return", "num_insns_constant_wide", "(", "low", ")", ";", "else", "if", "(", "mask64_operand", "(", "op", ",", "mode", ")", ")", "return", "2", ";", "else", "if", "(", "low", "==", "0", ")", "return", "num_insns_constant_wide", "(", "high", ")", "+", "1", ";", "else", "return", "(", "num_insns_constant_wide", "(", "high", ")", "+", "num_insns_constant_wide", "(", "low", ")", "+", "1", ")", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "it", "takes", "to", "form", "a", "constant", "in", "as", "many", "gprs", "are", "needed", "for", "MODE", "." ]

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

[]

[ "<s>", "void", "riscv_atomic_assign_expand_fenv", "(", "tree", "*", "hold", ",", "tree", "*", "clear", ",", "tree", "*", "update", ")", "{", "if", "(", "!", "(", "TARGET_HARD_FLOAT", "||", "TARGET_ZFINX", ")", ")", "return", ";", "tree", "frflags", "=", "GET_BUILTIN_DECL", "(", "CODE_FOR_riscv_frflags", ")", ";", "tree", "fsflags", "=", "GET_BUILTIN_DECL", "(", "CODE_FOR_riscv_fsflags", ")", ";", "tree", "old_flags", "=", "create_tmp_var_raw", "(", "RISCV_ATYPE_USI", ")", ";", "*", "hold", "=", "build4", "(", "TARGET_EXPR", ",", "RISCV_ATYPE_USI", ",", "old_flags", ",", "build_call_expr", "(", "frflags", ",", "0", ")", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "*", "clear", "=", "build_call_expr", "(", "fsflags", ",", "1", ",", "old_flags", ")", ";", "*", "update", "=", "NULL_TREE", ";", "}", "</s>" ]

[ "Implement", "TARGET_ATOMIC_ASSIGN_EXPAND_FENV", "." ]

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

[]

[ "<s>", "rtx", "rs6000_libcall_value", "(", "machine_mode", "mode", ")", "{", "unsigned", "int", "regno", ";", "if", "(", "TARGET_32BIT", "&&", "TARGET_POWERPC64", "&&", "mode", "==", "DImode", ")", "return", "rs6000_parallel_return", "(", "mode", ",", "2", ",", "SImode", ",", "GP_ARG_RETURN", ",", "1", ")", ";", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", "&&", "TARGET_HARD_FLOAT", ")", "regno", "=", "(", "mode", "==", "TDmode", ")", "?", "FP_ARG_RETURN", "+", "1", ":", "FP_ARG_RETURN", ";", "else", "if", "(", "SCALAR_FLOAT_MODE_NOT_VECTOR_P", "(", "mode", ")", "&&", "TARGET_HARD_FLOAT", ")", "regno", "=", "FP_ARG_RETURN", ";", "else", "if", "(", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "mode", ")", "&&", "TARGET_ALTIVEC", "&&", "TARGET_ALTIVEC_ABI", ")", "regno", "=", "ALTIVEC_ARG_RETURN", ";", "else", "if", "(", "COMPLEX_MODE_P", "(", "mode", ")", "&&", "targetm", ".", "calls", ".", "split_complex_arg", ")", "return", "rs6000_complex_function_value", "(", "mode", ")", ";", "else", "regno", "=", "GP_ARG_RETURN", ";", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "library", "function", "assuming", "the", "value", "has", "mode", "MODE", "." ]

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

[]

[ "<s>", "OperandMatchResultTy", "PatmosAsmParser", "::", "tryParseRegister", "(", "unsigned", "&", "RegNo", ",", "SMLoc", "&", "StartLoc", ",", "SMLoc", "&", "EndLoc", ")", "{", "if", "(", "ParseRegister", "(", "RegNo", ",", "StartLoc", ",", "EndLoc", ")", ")", "{", "return", "OperandMatchResultTy", "::", "MatchOperand_ParseFail", ";", "}", "if", "(", "RegNo", "==", "0", ")", "{", "return", "OperandMatchResultTy", "::", "MatchOperand_ParseFail", ";", "}", "return", "OperandMatchResultTy", "::", "MatchOperand_Success", ";", "}", "</s>" ]

[ "tryParseRegister", "-", "parse", "one", "register", "if", "possible" ]

[ "Patmos", "Patmos", "0" ]

[]

[ "<s>", "void", "LanaiFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "LanaiRegisterInfo", "*", "LRI", "=", "static_cast", "<", "const", "LanaiRegisterInfo", "*", ">", "(", "STI", ".", "getRegisterInfo", "(", ")", ")", ";", "int", "Offset", "=", "-", "4", ";", "MFI", ".", "CreateFixedObject", "(", "4", ",", "Offset", ",", "true", ")", ";", "Offset", "-=", "4", ";", "MFI", ".", "CreateFixedObject", "(", "4", ",", "Offset", ",", "true", ")", ";", "Offset", "-=", "4", ";", "if", "(", "LRI", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "MFI", ".", "CreateFixedObject", "(", "4", ",", "Offset", ",", "true", ")", ";", "SavedRegs", ".", "reset", "(", "LRI", "->", "getBaseRegister", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai", "Lanai", "4", "4", "4", "4", "4", "4" ]

[]

[ "<s>", "static", "void", "*", "ix86_init_cost", "(", "struct", "loop", "*", ")", "{", "unsigned", "*", "cost", "=", "XNEWVEC", "(", "unsigned", ",", "3", ")", ";", "cost", "[", "vect_prologue", "]", "=", "cost", "[", "vect_body", "]", "=", "cost", "[", "vect_epilogue", "]", "=", "0", ";", "return", "cost", ";", "}", "</s>" ]

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

[ "i386", "3", "0" ]

[]

[ "<s>", "void", "WaitcntBrackets", "::", "print", "(", "raw_ostream", "&", "OS", ")", "{", "OS", "<<", "'\\n'", ";", "for", "(", "auto", "T", ":", "inst_counter_types", "(", ")", ")", "{", "uint32_t", "LB", "=", "getScoreLB", "(", "T", ")", ";", "uint32_t", "UB", "=", "getScoreUB", "(", "T", ")", ";", "switch", "(", "T", ")", "{", "case", "VM_CNT", ":", "OS", "<<", "\" VM_CNT(\"", "<<", "UB", "-", "LB", "<<", "\"): \"", ";", "break", ";", "case", "LGKM_CNT", ":", "OS", "<<", "\" LGKM_CNT(\"", "<<", "UB", "-", "LB", "<<", "\"): \"", ";", "break", ";", "case", "EXP_CNT", ":", "OS", "<<", "\" EXP_CNT(\"", "<<", "UB", "-", "LB", "<<", "\"): \"", ";", "break", ";", "default", ":", "OS", "<<", "\" UNKNOWN(\"", "<<", "UB", "-", "LB", "<<", "\"): \"", ";", "break", ";", "}", "if", "(", "LB", "<", "UB", ")", "{", "for", "(", "int", "J", "=", "0", ";", "J", "<=", "getMaxVGPR", "(", ")", ";", "J", "++", ")", "{", "uint32_t", "RegScore", "=", "getRegScore", "(", "J", ",", "T", ")", ";", "if", "(", "RegScore", "<=", "LB", ")", "continue", ";", "uint32_t", "RelScore", "=", "RegScore", "-", "LB", "-", "1", ";", "if", "(", "J", "<", "SQ_MAX_PGM_VGPRS", "+", "EXTRA_VGPR_LDS", ")", "{", "OS", "<<", "RelScore", "<<", "\":v\"", "<<", "J", "<<", "\" \"", ";", "}", "else", "{", "OS", "<<", "RelScore", "<<", "\":ds \"", ";", "}", "}", "if", "(", "T", "==", "LGKM_CNT", ")", "{", "for", "(", "int", "J", "=", "0", ";", "J", "<=", "getMaxSGPR", "(", ")", ";", "J", "++", ")", "{", "uint32_t", "RegScore", "=", "getRegScore", "(", "J", "+", "NUM_ALL_VGPRS", ",", "LGKM_CNT", ")", ";", "if", "(", "RegScore", "<=", "LB", ")", "continue", ";", "uint32_t", "RelScore", "=", "RegScore", "-", "LB", "-", "1", ";", "OS", "<<", "RelScore", "<<", "\":s\"", "<<", "J", "<<", "\" \"", ";", "}", "}", "}", "OS", "<<", "'\\n'", ";", "}", "OS", "<<", "'\\n'", ";", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "AMDGPU", "\" VM_CNT(\"", "\"): \"", "\" LGKM_CNT(\"", "\"): \"", "\" EXP_CNT(\"", "\"): \"", "\" UNKNOWN(\"", "\"): \"", "0", "1", "\":v\"", "\" \"", "\":ds \"", "0", "1", "\":s\"", "\" \"" ]

[]

[ "<s>", "MCOperand", "SystemZMCInstLower", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "return", "MCOperand", "::", "CreateReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "return", "MCOperand", "::", "CreateImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "return", "lowerSymbolOperand", "(", "MO", ",", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "0", ")", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "return", "lowerSymbolOperand", "(", "MO", ",", "Mang", "->", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "MO", ".", "getOffset", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "{", "StringRef", "Name", "=", "MO", ".", "getSymbolName", "(", ")", ";", "return", "lowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetExternalSymbolSymbol", "(", "Name", ")", ",", "MO", ".", "getOffset", "(", ")", ")", ";", "}", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "return", "lowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ",", "0", ")", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "return", "lowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ",", "MO", ".", "getOffset", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "{", "const", "BlockAddress", "*", "BA", "=", "MO", ".", "getBlockAddress", "(", ")", ";", "return", "lowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetBlockAddressSymbol", "(", "BA", ")", ",", "MO", ".", "getOffset", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "SystemZ", "SystemZ", "\"unknown operand type\"", "0", "0" ]

[]

[ "<s>", "const", "JVMSubtarget", "&", "getSubtarget", "(", ")", "const", "{", "return", "*", "Subtarget", ";", "}", "</s>" ]

[ "getSubtarget", "-", "Return", "the", "subtarget", "for", "which", "this", "machine", "code", "is", "being", "compiled", "." ]

[ "JVM", "JVM" ]

[]

[ "<s>", "static", "bool", "rs6000_output_addr_const_extra", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_TOCREL", ":", "gcc_checking_assert", "(", "GET_CODE", "(", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "REG_P", "(", "XVECEXP", "(", "x", ",", "0", ",", "1", ")", ")", "&&", "REGNO", "(", "XVECEXP", "(", "x", ",", "0", ",", "1", ")", ")", "==", "TOC_REGISTER", ")", ";", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "if", "(", "x", "==", "tocrel_base", "&&", "tocrel_offset", "!=", "const0_rtx", ")", "{", "if", "(", "INTVAL", "(", "tocrel_offset", ")", ">=", "0", ")", "fprintf", "(", "file", ",", "\"+\"", ")", ";", "output_addr_const", "(", "file", ",", "CONST_CAST_RTX", "(", "tocrel_offset", ")", ")", ";", "}", "if", "(", "!", "TARGET_AIX", "||", "(", "TARGET_ELF", "&&", "TARGET_MINIMAL_TOC", ")", ")", "{", "putc", "(", "'-'", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "toc_label_name", ")", ";", "need_toc_init", "=", "1", ";", "}", "else", "if", "(", "TARGET_ELF", ")", "fputs", "(", "\"@toc\"", ",", "file", ")", ";", "return", "true", ";", "case", "UNSPEC_MACHOPIC_OFFSET", ":", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "putc", "(", "'-'", ",", "file", ")", ";", "machopic_output_function_base_name", "(", "file", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA", "." ]

[ "rs6000", "1", "0", "0", "0", "1", "0", "1", "0", "0", "0", "\"+\"", "1", "\"@toc\"", "0", "0" ]

[]

[ "<s>", "static", "ARMOperand", "*", "CreateMem", "(", "unsigned", "BaseRegNum", ",", "bool", "OffsetIsReg", ",", "const", "MCExpr", "*", "Offset", ",", "int", "OffsetRegNum", ",", "bool", "OffsetRegShifted", ",", "enum", "ARM_AM", "::", "ShiftOpc", "ShiftType", ",", "const", "MCExpr", "*", "ShiftAmount", ",", "bool", "Preindexed", ",", "bool", "Postindexed", ",", "bool", "Negative", ",", "bool", "Writeback", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "assert", "(", "(", "OffsetRegNum", "==", "-", "1", "||", "OffsetIsReg", ")", "&&", "\"OffsetRegNum must imply OffsetIsReg!\"", ")", ";", "assert", "(", "(", "!", "OffsetRegShifted", "||", "OffsetIsReg", ")", "&&", "\"OffsetRegShifted must imply OffsetIsReg!\"", ")", ";", "assert", "(", "(", "Offset", "||", "OffsetIsReg", ")", "&&", "\"Offset must exists unless register offset is used!\"", ")", ";", "assert", "(", "(", "!", "ShiftAmount", "||", "(", "OffsetIsReg", "&&", "OffsetRegShifted", ")", ")", "&&", "\"Cannot have shift amount without shifted register offset!\"", ")", ";", "assert", "(", "(", "!", "Offset", "||", "!", "OffsetIsReg", ")", "&&", "\"Cannot have expression offset and register offset!\"", ")", ";", "ARMOperand", "*", "Op", "=", "new", "ARMOperand", "(", "Memory", ")", ";", "Op", "->", "Mem", ".", "BaseRegNum", "=", "BaseRegNum", ";", "Op", "->", "Mem", ".", "OffsetIsReg", "=", "OffsetIsReg", ";", "if", "(", "OffsetIsReg", ")", "Op", "->", "Mem", ".", "Offset", ".", "RegNum", "=", "OffsetRegNum", ";", "else", "Op", "->", "Mem", ".", "Offset", ".", "Value", "=", "Offset", ";", "Op", "->", "Mem", ".", "OffsetRegShifted", "=", "OffsetRegShifted", ";", "Op", "->", "Mem", ".", "ShiftType", "=", "ShiftType", ";", "Op", "->", "Mem", ".", "ShiftAmount", "=", "ShiftAmount", ";", "Op", "->", "Mem", ".", "Preindexed", "=", "Preindexed", ";", "Op", "->", "Mem", ".", "Postindexed", "=", "Postindexed", ";", "Op", "->", "Mem", ".", "Negative", "=", "Negative", ";", "Op", "->", "Mem", ".", "Writeback", "=", "Writeback", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "Create", "a", "generalized", "memory", "operand", "." ]

[ "ARM", "ARM", "ARM_AM::ShiftOpc", "1", "\"OffsetRegNum must imply OffsetIsReg!\"", "\"OffsetRegShifted must imply OffsetIsReg!\"", "\"Offset must exists unless register offset is used!\"", "\"Cannot have shift amount without shifted register offset!\"", "\"Cannot have expression offset and register offset!\"", "ARM", "ARM" ]

[]

[ "<s>", "bool", "MipsTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "!", "AM", ".", "HasBaseReg", ")", "break", ";", "return", "false", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "1" ]

[]

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

[ "targetHandlesStackFrameRounding", "-", "Returns", "true", "if", "the", "target", "is", "responsible", "for", "rounding", "up", "the", "stack", "frame", "(", "probably", "at", "emitPrologue", "time", ")", "." ]

[ "PowerPC" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "static", "void", "ix86_emit_probe_stack_range", "(", "HOST_WIDE_INT", "first", ",", "HOST_WIDE_INT", "size", ")", "{", "if", "(", "size", "<=", "6", "*", "PROBE_INTERVAL", ")", "{", "HOST_WIDE_INT", "i", ";", "for", "(", "i", "=", "PROBE_INTERVAL", ";", "i", "<", "size", ";", "i", "+=", "PROBE_INTERVAL", ")", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "i", ")", ")", ")", ";", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "size", ")", ")", ")", ";", "}", "else", "{", "HOST_WIDE_INT", "rounded_size", ",", "last", ";", "struct", "scratch_reg", "sr", ";", "get_scratch_register_on_entry", "(", "&", "sr", ")", ";", "rounded_size", "=", "ROUND_DOWN", "(", "size", ",", "PROBE_INTERVAL", ")", ";", "emit_move_insn", "(", "sr", ".", "reg", ",", "GEN_INT", "(", "-", "first", ")", ")", ";", "last", "=", "first", "+", "rounded_size", ";", "emit_insn", "(", "ix86_gen_probe_stack_range", "(", "sr", ".", "reg", ",", "sr", ".", "reg", ",", "GEN_INT", "(", "-", "last", ")", ")", ")", ";", "if", "(", "size", "!=", "rounded_size", ")", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "sr", ".", "reg", ")", ",", "rounded_size", "-", "size", ")", ")", ";", "release_scratch_register_on_entry", "(", "&", "sr", ")", ";", "}", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "probe", "a", "range", "of", "stack", "addresses", "from", "FIRST", "to", "FIRST+SIZE", ",", "inclusive", ".", "These", "are", "offsets", "from", "the", "current", "stack", "pointer", "." ]

[ "i386", "6" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ")", "const", "{", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"esp\"", ",", "X86", "::", "ESP", ")", ".", "Case", "(", "\"rsp\"", ",", "X86", "::", "RSP", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"esp\"", "X86::ESP", "\"rsp\"", "X86::RSP", "0", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "static", "void", "rl78_note_reg_uses", "(", "char", "*", "dead", ",", "rtx", "s", ",", "rtx", "insn", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ",", "r", ";", "enum", "rtx_code", "code", ";", "if", "(", "!", "s", ")", "return", ";", "code", "=", "GET_CODE", "(", "s", ")", ";", "switch", "(", "code", ")", "{", "case", "REG", ":", "r", "=", "REGNO", "(", "s", ")", ";", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\"note use reg %d size %d on insn %d\\n\"", ",", "r", ",", "GET_MODE_SIZE", "(", "GET_MODE", "(", "s", ")", ")", ",", "INSN_UID", "(", "insn", ")", ")", ";", "print_rtl_single", "(", "dump_file", ",", "s", ")", ";", "}", "if", "(", "dead", "[", "r", "]", ")", "add_reg_note", "(", "insn", ",", "REG_DEAD", ",", "gen_rtx_REG", "(", "GET_MODE", "(", "s", ")", ",", "r", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "s", ")", ")", ";", "i", "++", ")", "dead", "[", "r", "+", "i", "]", "=", "0", ";", "return", ";", "case", "SCRATCH", ":", "case", "PC", ":", "return", ";", "case", "CONST_INT", ":", "case", "CONST_VECTOR", ":", "case", "CONST_DOUBLE", ":", "case", "CONST_FIXED", ":", "return", ";", "default", ":", "break", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "code", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "s", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "rl78_note_reg_uses", "(", "dead", ",", "XVECEXP", "(", "s", ",", "i", ",", "j", ")", ",", "insn", ")", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", ")", "rl78_note_reg_uses", "(", "dead", ",", "XEXP", "(", "s", ",", "i", ")", ",", "insn", ")", ";", "}", "}", "</s>" ]

[ "Add", "REG_DEAD", "notes", "using", "DEAD", "[", "reg", "]", "for", "rtx", "S", "which", "is", "part", "of", "INSN", ".", "This", "function", "scans", "for", "uses", "of", "registers", ";", "the", "last", "use", "(", "i.e", ".", "first", "encounter", "when", "scanning", "backwards", ")", "triggers", "a", "REG_DEAD", "note", "if", "the", "reg", "was", "previously", "in", "DEAD", "[", "]", "." ]

[ "rl78", "\"note use reg %d size %d on insn %d\\n\"", "0", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "DecodeStatus", "RISCVDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CS", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", ";", "if", "(", "(", "Bytes", "[", "0", "]", "&", "0x3", ")", "==", "0x3", ")", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Insn", "=", "support", "::", "endian", "::", "read32le", "(", "Bytes", ".", "data", "(", ")", ")", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureStdExtZdinx", "]", "&&", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "Feature64Bit", "]", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RV32Zdinx table (Double in Integer and\"", "\"rv32)\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableRV32Zdinx32", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "}", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureStdExtZfinx", "]", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RVZfinx table (Float in Integer):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableRVZfinx32", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RISCV32 table :\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "Size", "=", "4", ";", "}", "else", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "2", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Insn", "=", "support", "::", "endian", "::", "read16le", "(", "Bytes", ".", "data", "(", ")", ")", ";", "if", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "Feature64Bit", "]", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RISCV32Only_16 table (16-bit Instruction):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableRISCV32Only_16", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "2", ";", "return", "Result", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RISCV_C table (16-bit Instruction):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable16", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "Size", "=", "2", ";", "}", "return", "Result", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "0", "0x3", "0x3", "4", "0", "support::endian", "RISCV::FeatureStdExtZdinx", "RISCV::Feature64Bit", "\"Trying RV32Zdinx table (Double in Integer and\"", "\"rv32)\\n\"", "4", "RISCV::FeatureStdExtZfinx", "\"Trying RVZfinx table (Float in Integer):\\n\"", "4", "\"Trying RISCV32 table :\\n\"", "4", "2", "0", "support::endian", "RISCV::Feature64Bit", "\"Trying RISCV32Only_16 table (16-bit Instruction):\\n\"", "RISCV", "2", "\"Trying RISCV_C table (16-bit Instruction):\\n\"", "2" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "LanaiAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "static", "const", "MCFixupKindInfo", "Infos", "[", "Lanai", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"FIXUP_LANAI_NONE\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"FIXUP_LANAI_21\"", ",", "16", ",", "16", ",", "0", "}", ",", "{", "\"FIXUP_LANAI_21_F\"", ",", "16", ",", "16", ",", "0", "}", ",", "{", "\"FIXUP_LANAI_25\"", ",", "7", ",", "25", ",", "0", "}", ",", "{", "\"FIXUP_LANAI_32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"FIXUP_LANAI_HI16\"", ",", "16", ",", "16", ",", "0", "}", ",", "{", "\"FIXUP_LANAI_LO16\"", ",", "16", ",", "16", ",", "0", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai::NumTargetFixupKinds", "\"FIXUP_LANAI_NONE\"", "0", "32", "0", "\"FIXUP_LANAI_21\"", "16", "16", "0", "\"FIXUP_LANAI_21_F\"", "16", "16", "0", "\"FIXUP_LANAI_25\"", "7", "25", "0", "\"FIXUP_LANAI_32\"", "0", "32", "0", "\"FIXUP_LANAI_HI16\"", "16", "16", "0", "\"FIXUP_LANAI_LO16\"", "16", "16", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "static", "int", "rs6000_loop_align_max_skip", "(", "rtx_insn", "*", "label", ")", "{", "return", "(", "1", "<<", "rs6000_loop_align", "(", "label", ")", ")", "-", "1", ";", "}", "</s>" ]

[ "Implement", "TARGET_LOOP_ALIGN_MAX_SKIP", "." ]

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

[]

[ "<s>", "static", "bool", "rs6000_return_in_memory", "(", "tree", "type", ",", "tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "rs6000_darwin64_abi", "&&", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">", "0", ")", "{", "CUMULATIVE_ARGS", "valcum", ";", "rtx", "valret", ";", "valcum", ".", "words", "=", "0", ";", "valcum", ".", "fregno", "=", "FP_ARG_MIN_REG", ";", "valcum", ".", "vregno", "=", "ALTIVEC_ARG_MIN_REG", ";", "valret", "=", "rs6000_darwin64_record_arg", "(", "&", "valcum", ",", "type", ",", "1", ",", "true", ")", ";", "if", "(", "valret", ")", "return", "false", ";", "}", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "(", "aix_struct_return", "||", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "type", ")", ">", "8", ")", ")", "return", "true", ";", "if", "(", "TARGET_32BIT", "&&", "!", "TARGET_ALTIVEC_ABI", "&&", "ALTIVEC_VECTOR_MODE", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">", "(", "TARGET_ALTIVEC_ABI", "?", "16", ":", "8", ")", ")", "{", "static", "bool", "warned_for_return_big_vectors", "=", "false", ";", "if", "(", "!", "warned_for_return_big_vectors", ")", "{", "warning", "(", "0", ",", "\"GCC vector returned by reference: \"", "\"non-standard ABI extension with no compatibility guarantee\"", ")", ";", "warned_for_return_big_vectors", "=", "true", ";", "}", "return", "true", ";", "}", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "TARGET_IEEEQUAD", "&&", "TYPE_MODE", "(", "type", ")", "==", "TFmode", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "a", "nonzero", "value", "to", "say", "to", "return", "the", "function", "value", "in", "memory", ",", "just", "as", "large", "structures", "are", "always", "returned", ".", "TYPE", "will", "be", "the", "data", "type", "of", "the", "value", ",", "and", "FNTYPE", "will", "be", "the", "type", "of", "the", "function", "doing", "the", "returning", ",", "or", "@", "code", "{", "NULL", "}", "for", "libcalls", ".", "The", "AIX", "ABI", "for", "the", "RS/6000", "specifies", "that", "all", "structures", "are", "returned", "in", "memory", ".", "The", "Darwin", "ABI", "does", "the", "same", ".", "The", "SVR4", "ABI", "specifies", "that", "structures", "<", "=", "8", "bytes", "are", "returned", "in", "r3/r4", ",", "but", "a", "draft", "put", "them", "in", "memory", ",", "and", "GCC", "used", "to", "implement", "the", "draft", "instead", "of", "the", "final", "standard", ".", "Therefore", ",", "aix_struct_return", "controls", "this", "instead", "of", "DEFAULT_ABI", ";", "V.4", "targets", "needing", "backward", "compatibility", "can", "change", "DRAFT_V4_STRUCT_RET", "to", "override", "the", "default", ",", "and", "-m", "switches", "get", "the", "final", "word", ".", "See", "rs6000_override_options", "for", "more", "details", ".", "The", "PPC32", "SVR4", "ABI", "uses", "IEEE", "double", "extended", "for", "long", "double", ",", "if", "128-bit", "long", "double", "support", "is", "enabled", ".", "These", "values", "are", "returned", "in", "memory", ".", "int_size_in_bytes", "returns", "-1", "for", "variable", "size", "objects", ",", "which", "go", "in", "memory", "always", ".", "The", "cast", "to", "unsigned", "makes", "-1", ">", "8", "." ]

[ "rs6000", "0", "0", "1", "8", "16", "8", "0", "\"GCC vector returned by reference: \"", "\"non-standard ABI extension with no compatibility guarantee\"" ]

[]

[ "<s>", "void", "Thumb1InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "ARMSubtarget", "&", "st", "=", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "assert", "(", "ARM", "::", "GPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", "&&", "\"Thumb1 can only copy GPR registers\"", ")", ";", "if", "(", "st", ".", "hasV6Ops", "(", ")", "||", "ARM", "::", "hGPRRegClass", ".", "contains", "(", "SrcReg", ")", "||", "!", "ARM", "::", "tGPRRegClass", ".", "contains", "(", "DestReg", ")", ")", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tMOVr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ")", ";", "else", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tPUSH", ")", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tPOP", ")", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM::GPRRegClass", "\"Thumb1 can only copy GPR registers\"", "ARM::hGPRRegClass", "ARM::tGPRRegClass", "ARM::tMOVr", "ARM::tPUSH", "ARM::tPOP" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxationAdvanced", "(", "const", "MCFixup", "&", "Fixup", ",", "bool", "Resolved", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "MCInst", "const", "&", "MCB", "=", "DF", "->", "getInst", "(", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "isBundle", "(", "MCB", ")", ")", ";", "*", "RelaxTarget", "=", "nullptr", ";", "MCInst", "&", "MCI", "=", "const_cast", "<", "MCInst", "&", ">", "(", "HexagonMCInstrInfo", "::", "instruction", "(", "MCB", ",", "Fixup", ".", "getOffset", "(", ")", "/", "HEXAGON_INSTR_SIZE", ")", ")", ";", "if", "(", "!", "Resolved", ")", "{", "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "case", "fixup_Hexagon_B22_PCREL", ":", "default", ":", "return", "false", ";", "break", ";", "case", "fixup_Hexagon_B13_PCREL", ":", "case", "fixup_Hexagon_B15_PCREL", ":", "case", "fixup_Hexagon_B9_PCREL", ":", "case", "fixup_Hexagon_B7_PCREL", ":", "{", "if", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "MCB", ")", "<", "HEXAGON_PACKET_SIZE", ")", "{", "++", "relaxedCnt", ";", "*", "RelaxTarget", "=", "&", "MCI", ";", "setExtender", "(", "Layout", ".", "getAssembler", "(", ")", ".", "getContext", "(", ")", ")", ";", "return", "true", ";", "}", "else", "{", "return", "false", ";", "}", "break", ";", "}", "}", "}", "bool", "Relaxable", "=", "isInstRelaxable", "(", "MCI", ")", ";", "if", "(", "Relaxable", "==", "false", ")", "return", "false", ";", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "int64_t", "sValue", "=", "Value", ";", "int64_t", "maxValue", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "case", "fixup_Hexagon_B7_PCREL", ":", "maxValue", "=", "1", "<<", "8", ";", "break", ";", "case", "fixup_Hexagon_B9_PCREL", ":", "maxValue", "=", "1", "<<", "10", ";", "break", ";", "case", "fixup_Hexagon_B15_PCREL", ":", "maxValue", "=", "1", "<<", "16", ";", "break", ";", "case", "fixup_Hexagon_B22_PCREL", ":", "maxValue", "=", "1", "<<", "23", ";", "break", ";", "default", ":", "maxValue", "=", "INT64_MAX", ";", "break", ";", "}", "bool", "isFarAway", "=", "-", "maxValue", ">", "sValue", "||", "sValue", ">", "maxValue", "-", "1", ";", "if", "(", "isFarAway", ")", "{", "if", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "MCB", ")", "<", "HEXAGON_PACKET_SIZE", ")", "{", "++", "relaxedCnt", ";", "*", "RelaxTarget", "=", "&", "MCI", ";", "setExtender", "(", "Layout", ".", "getAssembler", "(", ")", ".", "getContext", "(", ")", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Target", "specific", "predicate", "for", "whether", "a", "given", "fixup", "requires", "the", "associated", "instruction", "to", "be", "relaxed", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "1", "8", "Hexagon", "1", "10", "Hexagon", "1", "16", "Hexagon", "1", "23", "1", "Hexagon" ]

[]

[ "<s>", "bool", "MOSInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "Cond", ".", "size", "(", ")", "==", "2", ")", ";", "auto", "&", "Val", "=", "Cond", "[", "1", "]", ";", "Val", ".", "setImm", "(", "!", "Val", ".", "getImm", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Reverses", "the", "branch", "condition", "of", "the", "specified", "condition", "list", ",", "returning", "false", "on", "success", "and", "true", "if", "it", "can", "not", "be", "reversed", "." ]

[ "MOS", "MOS", "2", "1" ]

[]

[ "<s>", "bool", "n7_consumed_by_ii_dep_p", "(", "rtx_insn", "*", "consumer", ",", "rtx", "def_reg", ")", "{", "rtx", "use_rtx", ";", "switch", "(", "get_attr_type", "(", "consumer", ")", ")", "{", "case", "TYPE_ALU", ":", "if", "(", "movd44_even_dep_p", "(", "consumer", ",", "def_reg", ")", ")", "return", "true", ";", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_MUL", ":", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_MAC", ":", "use_rtx", "=", "extract_mac_non_acc_rtx", "(", "consumer", ")", ";", "break", ";", "case", "TYPE_DIV", ":", "if", "(", "divmod_p", "(", "consumer", ")", ")", "use_rtx", "=", "SET_SRC", "(", "parallel_element", "(", "consumer", ",", "0", ")", ")", ";", "else", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_LOAD", ":", "if", "(", "post_update_insn_p", "(", "consumer", ")", ")", "use_rtx", "=", "extract_base_reg", "(", "consumer", ")", ";", "else", "use_rtx", "=", "extract_mem_rtx", "(", "consumer", ")", ";", "break", ";", "case", "TYPE_STORE", ":", "if", "(", "post_update_insn_p", "(", "consumer", ")", ")", "use_rtx", "=", "extract_base_reg", "(", "consumer", ")", ";", "else", "use_rtx", "=", "extract_mem_rtx", "(", "consumer", ")", ";", "if", "(", "reg_overlap_p", "(", "def_reg", ",", "use_rtx", ")", ")", "return", "true", ";", "if", "(", "!", "post_update_insn_p", "(", "consumer", ")", "&&", "!", "immed_offset_p", "(", "extract_mem_rtx", "(", "consumer", ")", ")", ")", "return", "false", ";", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_LOAD_MULTIPLE", ":", "use_rtx", "=", "extract_base_reg", "(", "consumer", ")", ";", "break", ";", "case", "TYPE_STORE_MULTIPLE", ":", "use_rtx", "=", "extract_base_reg", "(", "consumer", ")", ";", "if", "(", "reg_overlap_p", "(", "def_reg", ",", "use_rtx", ")", ")", "return", "true", ";", "use_rtx", "=", "extract_nth_access_rtx", "(", "consumer", ",", "0", ")", ";", "break", ";", "case", "TYPE_BRANCH", ":", "use_rtx", "=", "PATTERN", "(", "consumer", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "reg_overlap_p", "(", "def_reg", ",", "use_rtx", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Check", "the", "dependency", "between", "the", "producer", "defining", "DEF_REG", "and", "CONSUMER", "requiring", "input", "operand", "at", "II", "." ]

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

[]

[ "<s>", "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "Options", ".", "StackAlignmentOverride", ")", ",", "FrameLowering", "(", "*", "this", ",", "Subtarget", ")", ",", "InstrItins", "(", "Subtarget", ".", "getInstrItineraryData", "(", ")", ")", ",", "DL", "(", "computeDataLayout", "(", "*", "getSubtargetImpl", "(", ")", ")", ")", ",", "InstrInfo", "(", "*", "this", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "TSInfo", "(", "*", "this", ")", ",", "JITInfo", "(", "*", "this", ")", "{", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetCOFF", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "{", "assert", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", ";", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubDynamicNoPIC", ")", ";", "}", "}", "else", "if", "(", "Subtarget", ".", "isTargetELF", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "}", "if", "(", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "this", "->", "Options", ".", "FloatABIType", "=", "FloatABI", "::", "Hard", ";", "if", "(", "Subtarget", ".", "isTargetWin64", "(", ")", ")", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "X86", "target", "." ]

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

[]

[ "<s>", "static", "bool", "nvptx_warp_propagate", "(", "bool", "is_call", ",", "basic_block", "block", ",", "rtx_insn", "*", "insn", ")", "{", "return", "nvptx_propagate", "(", "is_call", ",", "block", ",", "insn", ",", "PM_read_write", ",", "warp_prop_gen", ",", "0", ",", "false", ")", ";", "}", "</s>" ]

[ "Propagate", "state", "that", "is", "live", "at", "start", "of", "BLOCK", "across", "the", "vectors", "of", "a", "single", "warp", ".", "Propagation", "is", "inserted", "just", "after", "INSN", ".", "IS_CALL", "and", "return", "as", "for", "nvptx_propagate", "." ]

[ "nvptx", "0" ]

[]