Datasets:

---

docz1105

/

ComBack

like 9

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

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

[ "X86" ]

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "unsigned", "RegNo", "=", "getMipsRegisterNumbering", "(", "Reg", ")", ";", "return", "RegNo", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "APFloat", "(", "MO", ".", "getFPImm", "(", ")", ")", ".", "bitcastToAPInt", "(", ")", ".", "getHiBits", "(", "32", ")", ".", "getLimitedValue", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isExpr", "(", ")", ")", "{", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "MCExpr", "::", "ExprKind", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "unsigned", "Ret", "=", "0", ";", "if", "(", "Kind", "==", "MCExpr", "::", "Binary", ")", "{", "const", "MCBinaryExpr", "*", "BE", "=", "static_cast", "<", "const", "MCBinaryExpr", "*", ">", "(", "Expr", ")", ";", "Expr", "=", "BE", "->", "getLHS", "(", ")", ";", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "BE", "->", "getRHS", "(", ")", ")", ";", "assert", "(", "(", "Kind", "==", "MCExpr", "::", "SymbolRef", ")", "&&", "CE", "&&", "\"Binary expression must be sym+const.\"", ")", ";", "Ret", "=", "CE", "->", "getValue", "(", ")", ";", "}", "if", "(", "Kind", "==", "MCExpr", "::", "SymbolRef", ")", "{", "Mips", "::", "Fixups", "FixupKind", ";", "switch", "(", "cast", "<", "MCSymbolRefExpr", ">", "(", "Expr", ")", "->", "getKind", "(", ")", ")", "{", "case", "MCSymbolRefExpr", "::", "VK_Mips_GPREL", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_GPREL16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_GOT_CALL", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_CALL16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_GOT", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_GOT16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_ABS_HI", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_HI16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_ABS_LO", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_LO16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_TLSGD", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_TLSGD", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_GOTTPREL", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_GOTTPREL", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_TPREL_HI", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_TPREL_HI", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_TPREL_LO", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_TPREL_LO", ";", "break", ";", "default", ":", "return", "Ret", ";", "}", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "FixupKind", ")", ")", ")", ";", "}", "return", "Ret", ";", "}", "llvm_unreachable", "(", "\"Unable to encode MCOperand!\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "32", "0", "\"Binary expression must be sym+const.\"", "Mips::Fixups", "Mips", "Mips::fixup_Mips_GPREL16", "Mips", "Mips::fixup_Mips_CALL16", "Mips", "Mips::fixup_Mips_GOT16", "Mips", "Mips::fixup_Mips_HI16", "Mips", "Mips::fixup_Mips_LO16", "Mips", "Mips::fixup_Mips_TLSGD", "Mips", "Mips::fixup_Mips_GOTTPREL", "Mips", "Mips::fixup_Mips_TPREL_HI", "Mips", "Mips::fixup_Mips_TPREL_LO", "0", "\"Unable to encode MCOperand!\"", "0" ]

[]

[ "<s>", "Register", "CSKYTargetLowering", "::", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "return", "CSKY", "::", "R1", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "typeid", "on", "entry", "to", "a", "landing", "pad", "." ]

[ "CSKY", "CSKY", "CSKY::R1" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "canInsertSelect", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "unsigned", "DstReg", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ",", "int", "&", "CondCycles", ",", "int", "&", "TrueCycles", ",", "int", "&", "FalseCycles", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";", "if", "(", "!", "RC", ")", "return", "false", ";", "if", "(", "!", "RI", ".", "getCommonSubClass", "(", "RC", ",", "MRI", ".", "getRegClass", "(", "DstReg", ")", ")", ")", "return", "false", ";", "unsigned", "ExtraCondLat", "=", "Cond", ".", "size", "(", ")", "!=", "1", ";", "if", "(", "AArch64", "::", "GPR64allRegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "AArch64", "::", "GPR32allRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "CondCycles", "=", "1", "+", "ExtraCondLat", ";", "TrueCycles", "=", "FalseCycles", "=", "1", ";", "if", "(", "canFoldIntoCSel", "(", "MRI", ",", "TrueReg", ")", ")", "TrueCycles", "=", "0", ";", "else", "if", "(", "canFoldIntoCSel", "(", "MRI", ",", "FalseReg", ")", ")", "FalseCycles", "=", "0", ";", "return", "true", ";", "}", "if", "(", "AArch64", "::", "FPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "AArch64", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "CondCycles", "=", "5", "+", "ExtraCondLat", ";", "TrueCycles", "=", "FalseCycles", "=", "2", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "possible", "to", "insert", "a", "select", "instruction", "that", "chooses", "between", "TrueReg", "and", "FalseReg", "based", "on", "the", "condition", "code", "in", "Cond", "." ]

[ "AArch64", "AArch64", "1", "AArch64::GPR64allRegClass", "AArch64::GPR32allRegClass", "1", "1", "0", "0", "AArch64::FPR64RegClass", "AArch64::FPR32RegClass", "5", "2" ]

[]

[ "<s>", "void", "ARMInstrInfo", "::", "reMaterialize", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "const", "MachineInstr", "*", "Orig", ")", "const", "{", "DebugLoc", "dl", "=", "Orig", "->", "getDebugLoc", "(", ")", ";", "if", "(", "Orig", "->", "getOpcode", "(", ")", "==", "ARM", "::", "MOVi2pieces", ")", "{", "RI", ".", "emitLoadConstPool", "(", "MBB", ",", "I", ",", "DestReg", ",", "Orig", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ",", "Orig", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ",", "Orig", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ",", "this", ",", "false", ",", "dl", ")", ";", "return", ";", "}", "MachineInstr", "*", "MI", "=", "MBB", ".", "getParent", "(", ")", "->", "CloneMachineInstr", "(", "Orig", ")", ";", "MI", "->", "getOperand", "(", "0", ")", ".", "setReg", "(", "DestReg", ")", ";", "MBB", ".", "insert", "(", "I", ",", "MI", ")", ";", "}", "</s>" ]

[ "Re-issue", "the", "specified", "'original", "'", "instruction", "at", "the", "specific", "location", "targeting", "a", "new", "destination", "register", "." ]

[ "ARM", "ARM", "ARM::MOVi2pieces", "1", "2", "3", "0" ]

[]

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

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

[ "MOS", "MOS" ]

[]

[ "<s>", "void", "ix86_expand_copysign", "(", "rtx", "operands", "[", "]", ")", "{", "machine_mode", "mode", ",", "vmode", ";", "rtx", "dest", ",", "vdest", ",", "op0", ",", "op1", ",", "mask", ",", "op2", ",", "op3", ";", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "if", "(", "mode", "==", "HFmode", ")", "vmode", "=", "V8HFmode", ";", "else", "if", "(", "mode", "==", "SFmode", ")", "vmode", "=", "V4SFmode", ";", "else", "if", "(", "mode", "==", "DFmode", ")", "vmode", "=", "V2DFmode", ";", "else", "if", "(", "mode", "==", "TFmode", ")", "vmode", "=", "mode", ";", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "rtx_equal_p", "(", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ")", "{", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "return", ";", "}", "dest", "=", "operands", "[", "0", "]", ";", "vdest", "=", "lowpart_subreg", "(", "vmode", ",", "dest", ",", "mode", ")", ";", "if", "(", "vdest", "==", "NULL_RTX", ")", "vdest", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "else", "dest", "=", "NULL_RTX", ";", "op1", "=", "lowpart_subreg", "(", "vmode", ",", "force_reg", "(", "mode", ",", "operands", "[", "2", "]", ")", ",", "mode", ")", ";", "mask", "=", "ix86_build_signbit_mask", "(", "vmode", ",", "0", ",", "0", ")", ";", "if", "(", "CONST_DOUBLE_P", "(", "operands", "[", "1", "]", ")", ")", "{", "op0", "=", "simplify_unary_operation", "(", "ABS", ",", "mode", ",", "operands", "[", "1", "]", ",", "mode", ")", ";", "if", "(", "op0", "==", "CONST0_RTX", "(", "mode", ")", ")", "{", "emit_move_insn", "(", "vdest", ",", "gen_rtx_AND", "(", "vmode", ",", "mask", ",", "op1", ")", ")", ";", "if", "(", "dest", ")", "emit_move_insn", "(", "dest", ",", "lowpart_subreg", "(", "mode", ",", "vdest", ",", "vmode", ")", ")", ";", "return", ";", "}", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<", "16", ")", "op0", "=", "ix86_build_const_vector", "(", "vmode", ",", "false", ",", "op0", ")", ";", "op0", "=", "force_reg", "(", "vmode", ",", "op0", ")", ";", "}", "else", "op0", "=", "lowpart_subreg", "(", "vmode", ",", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ",", "mode", ")", ";", "op2", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "op3", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "emit_move_insn", "(", "op2", ",", "gen_rtx_AND", "(", "vmode", ",", "gen_rtx_NOT", "(", "vmode", ",", "mask", ")", ",", "op0", ")", ")", ";", "emit_move_insn", "(", "op3", ",", "gen_rtx_AND", "(", "vmode", ",", "mask", ",", "op1", ")", ")", ";", "emit_move_insn", "(", "vdest", ",", "gen_rtx_IOR", "(", "vmode", ",", "op2", ",", "op3", ")", ")", ";", "if", "(", "dest", ")", "emit_move_insn", "(", "dest", ",", "lowpart_subreg", "(", "mode", ",", "vdest", ",", "vmode", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "copysign", "operation", ".", "Special", "case", "operand", "0", "being", "a", "constant", "." ]

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

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "TargetInstrInfo", "::", "isSchedulingBoundary", "(", "MI", ",", "MBB", ",", "MF", ")", ")", "{", "return", "true", ";", "}", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "RISCV", "::", "LOOP0setup", ":", "case", "RISCV", "::", "LOOP1setup", ":", "case", "RISCV", "::", "LOOP0setupi", ":", "case", "RISCV", "::", "LOOP1setupi", ":", "return", "true", ";", "default", ":", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "isSchedulingBoundary", "-", "Overrides", "the", "isSchedulingBoundary", "from", "Codegen/TargetInstrInfo.cpp", "to", "make", "it", "capable", "of", "identifying", "ENDBR", "intructions", "and", "prevent", "it", "from", "being", "re-scheduled", "." ]

[ "RI5CY", "RISCV", "RISCV::LOOP0setup", "RISCV::LOOP1setup", "RISCV::LOOP0setupi", "RISCV::LOOP1setupi" ]

[]

[ "<s>", "const", "uint32_t", "*", "ARMBaseRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "STI", ".", "isTargetNaCl", "(", ")", ")", "return", "CSR_NaCl_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_NoRegs_RegMask", ";", "return", "STI", ".", "isTargetDarwin", "(", ")", "?", "CSR_iOS_RegMask", ":", "CSR_AAPCS_RegMask", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "AArch64PreLegalizerCombiner", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "AU", ".", "setPreservesCFG", "(", ")", ";", "getSelectionDAGFallbackAnalysisUsage", "(", "AU", ")", ";", "AU", ".", "addRequired", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ";", "if", "(", "!", "IsOptNone", ")", "{", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "}", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "int", "arm_coproc_mem_operand", "(", "rtx", "op", ",", "bool", "wb", ")", "{", "return", "arm_coproc_mem_operand_wb", "(", "op", ",", "wb", "?", "2", ":", "1", ")", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "OP", "is", "a", "valid", "coprocessor", "memory", "address", "pattern", ".", "WB", "if", "true", "if", "writeback", "address", "modes", "are", "allowed", "." ]

[ "arm", "2", "1" ]

[]

[ "<s>", "static", "tree", "aarch64_int_or_fp_type", "(", "machine_mode", "mode", ",", "enum", "aarch64_type_qualifiers", "qualifiers", ")", "{", "?", "unsigned_int", "##", "M", "##", "_type_node", ":", "int", "##", "M", "##", "_type_node", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "return", "QUAL_TYPE", "(", "QI", ")", ";", "case", "E_HImode", ":", "return", "QUAL_TYPE", "(", "HI", ")", ";", "case", "E_SImode", ":", "return", "QUAL_TYPE", "(", "SI", ")", ";", "case", "E_DImode", ":", "return", "QUAL_TYPE", "(", "DI", ")", ";", "case", "E_TImode", ":", "return", "QUAL_TYPE", "(", "TI", ")", ";", "case", "E_OImode", ":", "return", "aarch64_simd_intOI_type_node", ";", "case", "E_CImode", ":", "return", "aarch64_simd_intCI_type_node", ";", "case", "E_XImode", ":", "return", "aarch64_simd_intXI_type_node", ";", "case", "E_HFmode", ":", "return", "aarch64_fp16_type_node", ";", "case", "E_SFmode", ":", "return", "float_type_node", ";", "case", "E_DFmode", ":", "return", "double_type_node", ";", "case", "E_BFmode", ":", "return", "bfloat16_type_node", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Helper", "function", "for", "aarch64_simd_builtin_type", "." ]

[ "aarch64" ]

[]

[ "<s>", "unsigned", "internalKnownBits", "(", ")", "const", "{", "return", "Unalign", "?", "Unalign", ":", "KnownBits", ";", "}", "</s>" ]

[ "Compute", "the", "number", "of", "known", "offset", "bits", "internally", "to", "this", "block", "." ]

[ "ARM" ]

[]

[ "<s>", "const", "Triple", "&", "getTargetTriple", "(", ")", "const", "{", "return", "TargetTriple", ";", "}", "</s>" ]

[ "Get", "the", "target", "triple", "which", "is", "a", "string", "describing", "the", "target", "host", "." ]

[ "FPGA" ]

[]

[ "<s>", "unsigned", "X86FrameLowering", "::", "getInitialCFARegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "TRI", "->", "getDwarfRegNum", "(", "StackPtr", ",", "true", ")", ";", "}", "</s>" ]

[ "Return", "initial", "CFA", "register", "value", "i.e", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "rtx_insn", "*", "mips_call_tls_get_addr", "(", "rtx", "sym", ",", "enum", "mips_symbol_type", "type", ",", "rtx", "v0", ")", "{", "rtx", "loc", ",", "a0", ";", "rtx_insn", "*", "insn", ";", "a0", "=", "gen_rtx_REG", "(", "Pmode", ",", "GP_ARG_FIRST", ")", ";", "if", "(", "!", "mips_tls_symbol", ")", "mips_tls_symbol", "=", "init_one_libfunc", "(", "\"__tls_get_addr\"", ")", ";", "loc", "=", "mips_unspec_address", "(", "sym", ",", "type", ")", ";", "start_sequence", "(", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "a0", ",", "gen_rtx_LO_SUM", "(", "Pmode", ",", "pic_offset_table_rtx", ",", "loc", ")", ")", ")", ";", "insn", "=", "mips_expand_call", "(", "MIPS_CALL_NORMAL", ",", "v0", ",", "mips_tls_symbol", ",", "const0_rtx", ",", "NULL_RTX", ",", "false", ")", ";", "RTL_CONST_CALL_P", "(", "insn", ")", "=", "1", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "a0", ")", ";", "insn", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "insn", ";", "}", "</s>" ]

[ "Return", "an", "instruction", "sequence", "that", "calls", "__tls_get_addr", ".", "SYM", "is", "the", "TLS", "symbol", "we", "are", "referencing", "and", "TYPE", "is", "the", "symbol", "type", "to", "use", "(", "either", "global", "dynamic", "or", "local", "dynamic", ")", ".", "V0", "is", "an", "RTX", "for", "the", "return", "value", "location", "." ]

[ "mips", "\"__tls_get_addr\"", "1" ]

[]

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

[ "Do", "not", "merge", "vector", "stores", "after", "legalization", "because", "that", "may", "conflict", "with", "x86-specific", "store", "splitting", "optimizations", "." ]

[ "AMDGPU" ]

[]

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

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

[ "FISC", "FISC", "0", "\"unexpected inline asm memory operand\"", "\"[\"", "FISC", "\", \"", "\"]\"" ]

[]

[ "<s>", "static", "reg_class_t", "m32c_preferred_reload_class", "(", "rtx", "x", ",", "reg_class_t", "rclass", ")", "{", "reg_class_t", "newclass", "=", "rclass", ";", "fprintf", "(", "stderr", ",", "\"\\npreferred_reload_class for %s is \"", ",", "class_names", "[", "rclass", "]", ")", ";", "if", "(", "rclass", "==", "NO_REGS", ")", "rclass", "=", "GET_MODE", "(", "x", ")", "==", "QImode", "?", "HL_REGS", ":", "R03_REGS", ";", "if", "(", "reg_classes_intersect_p", "(", "rclass", ",", "CR_REGS", ")", ")", "{", "switch", "(", "GET_MODE", "(", "x", ")", ")", "{", "case", "QImode", ":", "newclass", "=", "HL_REGS", ";", "break", ";", "default", ":", "break", ";", "}", "}", "else", "if", "(", "newclass", "==", "QI_REGS", "&&", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ">", "2", ")", "newclass", "=", "SI_REGS", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ">", "4", "&&", "!", "reg_class_subset_p", "(", "R03_REGS", ",", "rclass", ")", ")", "newclass", "=", "DI_REGS", ";", "rclass", "=", "reduce_class", "(", "rclass", ",", "newclass", ",", "rclass", ")", ";", "if", "(", "GET_MODE", "(", "x", ")", "==", "QImode", ")", "rclass", "=", "reduce_class", "(", "rclass", ",", "HL_REGS", ",", "rclass", ")", ";", "fprintf", "(", "stderr", ",", "\"%s\\n\"", ",", "class_names", "[", "rclass", "]", ")", ";", "debug_rtx", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "PLUS", ")", "fprintf", "(", "stderr", ",", "\"Glorm!\\n\"", ")", ";", "return", "rclass", ";", "}", "</s>" ]

[ "Implements", "PREFERRED_RELOAD_CLASS", ".", "In", "general", ",", "prefer", "general", "registers", "of", "the", "appropriate", "size", "." ]

[ "m32c", "\"\\npreferred_reload_class for %s is \"", "2", "4", "\"%s\\n\"", "0", "0", "0", "\"Glorm!\\n\"" ]

[]

[ "<s>", "unsigned", "ARMTargetLowering", "::", "getABIAlignmentForCallingConv", "(", "Type", "*", "ArgTy", ",", "DataLayout", "DL", ")", "const", "{", "if", "(", "!", "ArgTy", "->", "isVectorTy", "(", ")", ")", "return", "DL", ".", "getABITypeAlignment", "(", "ArgTy", ")", ";", "return", "std", "::", "min", "(", "DL", ".", "getABITypeAlignment", "(", "ArgTy", ")", ",", "(", "unsigned", ")", "DL", ".", "getStackAlignment", "(", ")", ".", "value", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "correct", "alignment", "for", "the", "current", "calling", "convention", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "const", "TargetRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "AAP" ]

[]

[ "<s>", "static", "bool", "alpha_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "return", "mode", "==", "V8QImode", "||", "mode", "==", "V4HImode", "||", "mode", "==", "V2SImode", ";", "}", "</s>" ]

[ "Alpha", "implements", "a", "couple", "of", "integer", "vector", "mode", "operations", "when", "TARGET_MAX", "is", "enabled", ".", "We", "do", "not", "check", "TARGET_MAX", "here", ",", "however", ",", "which", "allows", "the", "vectorizer", "to", "operate", "on", "e.g", ".", "move", "instructions", ",", "or", "when", "expand_vector_operations", "can", "do", "something", "useful", "." ]

[ "alpha" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", "&&", "!", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getHasPushSequences", "(", ")", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

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

[]

[ "<s>", "ConstantPool", "*", "AssemblerConstantPools", "::", "getConstantPool", "(", "const", "MCSection", "*", "Section", ")", "{", "ConstantPoolMapTy", "::", "iterator", "CP", "=", "ConstantPools", ".", "find", "(", "Section", ")", ";", "if", "(", "CP", "==", "ConstantPools", ".", "end", "(", ")", ")", "return", "nullptr", ";", "return", "&", "CP", "->", "second", ";", "}", "</s>" ]

[ "Return", "a", "pseudo", "source", "value", "referencing", "the", "constant", "pool", "." ]

[ "ARM" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "X86TargetLowering", "::", "shouldExpandAtomicLoadInIR", "(", "LoadInst", "*", "LI", ")", "const", "{", "auto", "PTy", "=", "cast", "<", "PointerType", ">", "(", "LI", "->", "getPointerOperand", "(", ")", "->", "getType", "(", ")", ")", ";", "return", "needsCmpXchgNb", "(", "PTy", "->", "getElementType", "(", ")", ")", "?", "AtomicExpansionKind", "::", "CmpXChg", ":", "AtomicExpansionKind", "::", "None", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "(", "atomic", ")", "load", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "getMCOpcodeFromPseudo", "(", "Opc", ")", ";", "unsigned", "DescSize", "=", "Desc", ".", "getSize", "(", ")", ";", "if", "(", "isFixedSize", "(", "MI", ")", ")", "{", "unsigned", "Size", "=", "DescSize", ";", "if", "(", "MI", ".", "isBranch", "(", ")", "&&", "ST", ".", "hasOffset3fBug", "(", ")", ")", "Size", "+=", "4", ";", "return", "Size", ";", "}", "if", "(", "isVALU", "(", "MI", ")", "||", "isSALU", "(", "MI", ")", ")", "{", "if", "(", "isDPP", "(", "MI", ")", ")", "return", "DescSize", ";", "bool", "HasLiteral", "=", "false", ";", "for", "(", "int", "I", "=", "0", ",", "E", "=", "MI", ".", "getNumExplicitOperands", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "const", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "I", ")", ";", "const", "MCOperandInfo", "&", "OpInfo", "=", "Desc", ".", "OpInfo", "[", "I", "]", ";", "if", "(", "isLiteralConstantLike", "(", "Op", ",", "OpInfo", ")", ")", "{", "HasLiteral", "=", "true", ";", "break", ";", "}", "}", "return", "HasLiteral", "?", "DescSize", "+", "4", ":", "DescSize", ";", "}", "if", "(", "isMIMG", "(", "MI", ")", ")", "{", "int", "VAddr0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "vaddr0", ")", ";", "if", "(", "VAddr0Idx", "<", "0", ")", "return", "8", ";", "int", "RSrcIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "srsrc", ")", ";", "return", "8", "+", "4", "*", "(", "(", "RSrcIdx", "-", "VAddr0Idx", "+", "2", ")", "/", "4", ")", ";", "}", "switch", "(", "Opc", ")", "{", "case", "TargetOpcode", "::", "BUNDLE", ":", "return", "getInstBundleSize", "(", "MI", ")", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "case", "TargetOpcode", "::", "INLINEASM_BR", ":", "{", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "char", "*", "AsmStr", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ";", "return", "getInlineAsmLength", "(", "AsmStr", ",", "*", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ",", "&", "ST", ")", ";", "}", "default", ":", "if", "(", "MI", ".", "isMetaInstruction", "(", ")", ")", "return", "0", ";", "return", "DescSize", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "4", "0", "4", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "0", "8", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "8", "4", "2", "4", "0", "0" ]

[]

[ "<s>", "void", "s390_reload_symref_address", "(", "rtx", "reg", ",", "rtx", "mem", ",", "rtx", "scratch", ",", "bool", "tomem", ")", "{", "if", "(", "CONST_INT_P", "(", "mem", ")", "||", "GET_CODE", "(", "mem", ")", "==", "CONST_DOUBLE", "||", "GET_CODE", "(", "mem", ")", "==", "CONST_WIDE_INT", "||", "GET_CODE", "(", "mem", ")", "==", "CONST_VECTOR", "||", "GET_CODE", "(", "mem", ")", "==", "CONST", ")", "mem", "=", "force_const_mem", "(", "GET_MODE", "(", "reg", ")", ",", "mem", ")", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "if", "(", "!", "tomem", "&&", "REGNO", "(", "reg", ")", "<", "FIRST_PSEUDO_REGISTER", "&&", "REGNO_REG_CLASS", "(", "REGNO", "(", "reg", ")", ")", "==", "ADDR_REGS", "&&", "GET_MODE", "(", "reg", ")", "==", "GET_MODE", "(", "scratch", ")", ")", "scratch", "=", "reg", ";", "s390_reload_larl_operand", "(", "scratch", ",", "XEXP", "(", "mem", ",", "0", ")", ",", "scratch", ")", ";", "if", "(", "tomem", ")", "emit_move_insn", "(", "replace_equiv_address", "(", "mem", ",", "scratch", ")", ",", "reg", ")", ";", "else", "emit_move_insn", "(", "reg", ",", "replace_equiv_address", "(", "mem", ",", "scratch", ")", ")", ";", "}", "</s>" ]

[ "Generate", "what", "is", "necessary", "to", "move", "between", "REG", "and", "MEM", "using", "SCRATCH", ".", "The", "direction", "is", "given", "by", "TOMEM", "." ]

[ "s390", "0" ]

[]

[ "<s>", "bool", "isProfitableToDupForIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumCycles", ",", "BranchProbability", "Probability", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "profitable", "for", "if-converter", "to", "duplicate", "instructions", "of", "specified", "accumulated", "instruction", "latencies", "in", "the", "specified", "MBB", "to", "enable", "if-conversion", "." ]

[ "PowerPC" ]

[]

[ "<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", "." ]

[ "AMDGPU", "R600", "0", "AMDGPU::OpName", "R600", "R600", "0", "4" ]

[]

[ "<s>", "bool", "GCNScheduleDAGMILive", "::", "isTriviallyReMaterializable", "(", "const", "MachineInstr", "&", "MI", ",", "AAResults", "*", "AA", ")", "{", "if", "(", "!", "TII", "->", "isTriviallyReMaterializable", "(", "MI", ",", "AA", ")", ")", "return", "false", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isUse", "(", ")", "&&", "MO", ".", "getReg", "(", ")", ".", "isVirtual", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "is", "trivially", "rematerializable", ",", "meaning", "it", "has", "no", "side", "effects", "and", "requires", "no", "operands", "that", "are", "n't", "always", "available", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "avr_expand_prologue", "(", "void", ")", "{", "HARD_REG_SET", "set", ";", "HOST_WIDE_INT", "size", ";", "size", "=", "get_frame_size", "(", ")", "+", "avr_outgoing_args_size", "(", ")", ";", "cfun", "->", "machine", "->", "stack_usage", "=", "0", ";", "if", "(", "cfun", "->", "machine", "->", "is_naked", ")", "{", "return", ";", "}", "avr_regs_to_save", "(", "&", "set", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ")", "{", "int", "treg", "=", "AVR_TMP_REGNO", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", ")", "emit_insn", "(", "gen_enable_interrupt", "(", ")", ")", ";", "if", "(", "cfun", "->", "machine", "->", "gasisr", ".", "maybe", ")", "{", "cfun", "->", "machine", "->", "gasisr", ".", "yes", "=", "1", ";", "treg", "=", "avr_hregs_split_reg", "(", "&", "set", ")", ";", "if", "(", "treg", "<", "0", ")", "treg", "=", "AVR_TMP_REGNO", ";", "cfun", "->", "machine", "->", "gasisr", ".", "regno", "=", "treg", ";", "cfun", "->", "machine", "->", "stack_usage", "+=", "3", "+", "(", "treg", "!=", "AVR_TMP_REGNO", ")", ";", "emit_insn", "(", "gen_gasisr", "(", "GEN_INT", "(", "GASISR_Prologue", ")", ",", "GEN_INT", "(", "treg", ")", ")", ")", ";", "}", "else", "{", "emit_push_byte", "(", "AVR_ZERO_REGNO", ",", "true", ")", ";", "emit_push_byte", "(", "AVR_TMP_REGNO", ",", "true", ")", ";", "emit_push_sfr", "(", "sreg_rtx", ",", "false", ",", "false", ",", "AVR_TMP_REGNO", ")", ";", "emit_move_insn", "(", "zero_reg_rtx", ",", "const0_rtx", ")", ";", "emit_use", "(", "zero_reg_rtx", ")", ";", "}", "if", "(", "AVR_HAVE_RAMPD", ")", "emit_push_sfr", "(", "rampd_rtx", ",", "false", ",", "true", ",", "treg", ")", ";", "if", "(", "AVR_HAVE_RAMPX", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_X", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_X", "+", "1", ")", ")", "{", "emit_push_sfr", "(", "rampx_rtx", ",", "false", ",", "true", ",", "treg", ")", ";", "}", "if", "(", "AVR_HAVE_RAMPY", "&&", "(", "frame_pointer_needed", "||", "(", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Y", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Y", "+", "1", ")", ")", ")", ")", "{", "emit_push_sfr", "(", "rampy_rtx", ",", "false", ",", "true", ",", "treg", ")", ";", "}", "if", "(", "AVR_HAVE_RAMPZ", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Z", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Z", "+", "1", ")", ")", "{", "emit_push_sfr", "(", "rampz_rtx", ",", "false", ",", "AVR_HAVE_RAMPD", ",", "treg", ")", ";", "}", "}", "avr_prologue_setup_frame", "(", "size", ",", "set", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "cfun", "->", "machine", "->", "stack_usage", "+", "INCOMING_FRAME_SP_OFFSET", ";", "}", "</s>" ]

[ "Output", "function", "prologue", "." ]

[ "avr", "0", "1", "0", "3", "1", "1", "1" ]

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "eliminateSGPRToVGPRSpillFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "MI", ",", "int", "FI", ",", "RegScavenger", "*", "RS", ",", "LiveIntervals", "*", "LIS", ")", "const", "{", "bool", "NeedsCFI", "=", "false", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_SPILL_S1024_CFI_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S512_CFI_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S256_CFI_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S224_CFI_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S192_CFI_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S160_CFI_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S128_CFI_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S96_CFI_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S64_CFI_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S32_CFI_SAVE", ":", "NeedsCFI", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "AMDGPU", "::", "SI_SPILL_S1024_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S512_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S256_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S224_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S192_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S160_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S128_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S96_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S64_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S32_SAVE", ":", "return", "spillSGPR", "(", "MI", ",", "FI", ",", "RS", ",", "LIS", ",", "true", ",", "NeedsCFI", ")", ";", "case", "AMDGPU", "::", "SI_SPILL_S1024_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S512_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S256_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S224_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S192_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S160_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S128_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S96_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S64_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S32_RESTORE", ":", "return", "restoreSGPR", "(", "MI", ",", "FI", ",", "RS", ",", "LIS", ",", "true", ")", ";", "default", ":", "llvm_unreachable", "(", "\"not an SGPR spill instruction\"", ")", ";", "}", "}", "</s>" ]

[ "Special", "case", "of", "eliminateFrameIndex", "." ]

[ "AMDGPU", "SI", "AMDGPU::SI_SPILL_S1024_CFI_SAVE", "AMDGPU::SI_SPILL_S512_CFI_SAVE", "AMDGPU::SI_SPILL_S256_CFI_SAVE", "AMDGPU::SI_SPILL_S224_CFI_SAVE", "AMDGPU::SI_SPILL_S192_CFI_SAVE", "AMDGPU::SI_SPILL_S160_CFI_SAVE", "AMDGPU::SI_SPILL_S128_CFI_SAVE", "AMDGPU::SI_SPILL_S96_CFI_SAVE", "AMDGPU::SI_SPILL_S64_CFI_SAVE", "AMDGPU::SI_SPILL_S32_CFI_SAVE", "AMDGPU::SI_SPILL_S1024_SAVE", "AMDGPU::SI_SPILL_S512_SAVE", "AMDGPU::SI_SPILL_S256_SAVE", "AMDGPU::SI_SPILL_S224_SAVE", "AMDGPU::SI_SPILL_S192_SAVE", "AMDGPU::SI_SPILL_S160_SAVE", "AMDGPU::SI_SPILL_S128_SAVE", "AMDGPU::SI_SPILL_S96_SAVE", "AMDGPU::SI_SPILL_S64_SAVE", "AMDGPU::SI_SPILL_S32_SAVE", "AMDGPU::SI_SPILL_S1024_RESTORE", "AMDGPU::SI_SPILL_S512_RESTORE", "AMDGPU::SI_SPILL_S256_RESTORE", "AMDGPU::SI_SPILL_S224_RESTORE", "AMDGPU::SI_SPILL_S192_RESTORE", "AMDGPU::SI_SPILL_S160_RESTORE", "AMDGPU::SI_SPILL_S128_RESTORE", "AMDGPU::SI_SPILL_S96_RESTORE", "AMDGPU::SI_SPILL_S64_RESTORE", "AMDGPU::SI_SPILL_S32_RESTORE", "\"not an SGPR spill instruction\"" ]

[]

[ "<s>", "bool", "aarch64_sve_ld1r_operand_p", "(", "rtx", "op", ")", "{", "struct", "aarch64_address_info", "addr", ";", "scalar_mode", "mode", ";", "return", "(", "MEM_P", "(", "op", ")", "&&", "is_a", "<", "scalar_mode", ">", "(", "GET_MODE", "(", "op", ")", ",", "&", "mode", ")", "&&", "aarch64_classify_address", "(", "&", "addr", ",", "XEXP", "(", "op", ",", "0", ")", ",", "mode", ",", "false", ")", "&&", "addr", ".", "type", "==", "ADDRESS_REG_IMM", "&&", "offset_6bit_unsigned_scaled_p", "(", "mode", ",", "addr", ".", "const_offset", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "valid", "MEM", "operand", "for", "an", "SVE", "LD1R", "instruction", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "bool", "NVPTXTTIImpl", "::", "isSourceOfDivergence", "(", "const", "Value", "*", "V", ")", "{", "if", "(", "const", "Argument", "*", "Arg", "=", "dyn_cast", "<", "Argument", ">", "(", "V", ")", ")", "return", "!", "isKernelFunction", "(", "*", "Arg", "->", "getParent", "(", ")", ")", ";", "if", "(", "const", "Instruction", "*", "I", "=", "dyn_cast", "<", "Instruction", ">", "(", "V", ")", ")", "{", "if", "(", "const", "LoadInst", "*", "LI", "=", "dyn_cast", "<", "LoadInst", ">", "(", "I", ")", ")", "{", "unsigned", "AS", "=", "LI", "->", "getPointerAddressSpace", "(", ")", ";", "return", "AS", "==", "ADDRESS_SPACE_GENERIC", "||", "AS", "==", "ADDRESS_SPACE_LOCAL", ";", "}", "if", "(", "I", "->", "isAtomic", "(", ")", ")", "return", "true", ";", "if", "(", "const", "IntrinsicInst", "*", "II", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "I", ")", ")", "{", "if", "(", "readsThreadIndex", "(", "II", ")", "||", "readsLaneId", "(", "II", ")", ")", "return", "true", ";", "if", "(", "isNVVMAtomic", "(", "II", ")", ")", "return", "true", ";", "}", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequiredID", "(", "MachineDominatorsID", ")", ";", "AU", ".", "addRequiredID", "(", "MachineLoopInfoID", ")", ";", "AU", ".", "addPreserved", "<", "SlotIndexes", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "LiveIntervals", ">", "(", ")", ";", "AU", ".", "addPreservedID", "(", "LiveVariablesID", ")", ";", "AU", ".", "addPreservedID", "(", "MachineLoopInfoID", ")", ";", "AU", ".", "addPreservedID", "(", "MachineDominatorsID", ")", ";", "AU", ".", "setPreservesCFG", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "void", "R600TargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "AMDGPUTargetLowering", "::", "ReplaceNodeResults", "(", "N", ",", "Results", ",", "DAG", ")", ";", "return", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "if", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i1", ")", "{", "Results", ".", "push_back", "(", "LowerFPTOUINT", "(", "N", "->", "getOperand", "(", "0", ")", ",", "DAG", ")", ")", ";", "return", ";", "}", "case", "ISD", "::", "FP_TO_SINT", ":", "{", "SDValue", "Result", ";", "if", "(", "expandFP_TO_SINT", "(", "N", ",", "Result", ",", "DAG", ")", ")", "Results", ".", "push_back", "(", "Result", ")", ";", "return", ";", "}", "case", "ISD", "::", "SDIVREM", ":", "{", "SDValue", "Op", "=", "SDValue", "(", "N", ",", "1", ")", ";", "SDValue", "RES", "=", "LowerSDIVREM", "(", "Op", ",", "DAG", ")", ";", "Results", ".", "push_back", "(", "RES", ")", ";", "Results", ".", "push_back", "(", "RES", ".", "getValue", "(", "1", ")", ")", ";", "break", ";", "}", "case", "ISD", "::", "UDIVREM", ":", "{", "SDValue", "Op", "=", "SDValue", "(", "N", ",", "0", ")", ";", "LowerUDIVREM64", "(", "Op", ",", "DAG", ",", "Results", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "AMDGPU", "R600", "AMDGPU", "ISD::FP_TO_UINT", "0", "MVT::i1", "0", "ISD::FP_TO_SINT", "SI", "ISD::SDIVREM", "1", "1", "ISD::UDIVREM", "0" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "llvm_unreachable", "(", "\"relaxInstruction() unimplemented\"", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "\"relaxInstruction() unimplemented\"" ]

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "getMCOpcodeFromPseudo", "(", "Opc", ")", ";", "unsigned", "DescSize", "=", "Desc", ".", "getSize", "(", ")", ";", "if", "(", "isFixedSize", "(", "MI", ")", ")", "{", "unsigned", "Size", "=", "DescSize", ";", "if", "(", "MI", ".", "isBranch", "(", ")", "&&", "ST", ".", "hasOffset3fBug", "(", ")", ")", "Size", "+=", "4", ";", "return", "Size", ";", "}", "if", "(", "isVALU", "(", "MI", ")", "||", "isSALU", "(", "MI", ")", ")", "{", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "if", "(", "Src0Idx", "==", "-", "1", ")", "return", "DescSize", ";", "if", "(", "isLiteralConstantLike", "(", "MI", ".", "getOperand", "(", "Src0Idx", ")", ",", "Desc", ".", "OpInfo", "[", "Src0Idx", "]", ")", ")", "return", "isVOP3", "(", "MI", ")", "?", "12", ":", "(", "DescSize", "+", "4", ")", ";", "int", "Src1Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "if", "(", "Src1Idx", "==", "-", "1", ")", "return", "DescSize", ";", "if", "(", "isLiteralConstantLike", "(", "MI", ".", "getOperand", "(", "Src1Idx", ")", ",", "Desc", ".", "OpInfo", "[", "Src1Idx", "]", ")", ")", "return", "isVOP3", "(", "MI", ")", "?", "12", ":", "(", "DescSize", "+", "4", ")", ";", "int", "Src2Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src2", ")", ";", "if", "(", "Src2Idx", "==", "-", "1", ")", "return", "DescSize", ";", "if", "(", "isLiteralConstantLike", "(", "MI", ".", "getOperand", "(", "Src2Idx", ")", ",", "Desc", ".", "OpInfo", "[", "Src2Idx", "]", ")", ")", "return", "isVOP3", "(", "MI", ")", "?", "12", ":", "(", "DescSize", "+", "4", ")", ";", "return", "DescSize", ";", "}", "if", "(", "isMIMG", "(", "MI", ")", ")", "{", "int", "VAddr0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "vaddr0", ")", ";", "if", "(", "VAddr0Idx", "<", "0", ")", "return", "8", ";", "int", "RSrcIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "srsrc", ")", ";", "return", "8", "+", "4", "*", "(", "(", "RSrcIdx", "-", "VAddr0Idx", "+", "2", ")", "/", "4", ")", ";", "}", "switch", "(", "Opc", ")", "{", "case", "TargetOpcode", "::", "BUNDLE", ":", "return", "getInstBundleSize", "(", "MI", ")", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "case", "TargetOpcode", "::", "INLINEASM_BR", ":", "{", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "char", "*", "AsmStr", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ";", "return", "getInlineAsmLength", "(", "AsmStr", ",", "*", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ",", "&", "ST", ")", ";", "}", "default", ":", "if", "(", "MI", ".", "isMetaInstruction", "(", ")", ")", "return", "0", ";", "return", "DescSize", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "4", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "12", "4", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "12", "4", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "12", "4", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "0", "8", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "8", "4", "2", "4", "0", "0" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "SIInstrInfo", "::", "getOpRegClass", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpNo", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "MI", ".", "isVariadic", "(", ")", "||", "OpNo", ">=", "Desc", ".", "getNumOperands", "(", ")", "||", "Desc", ".", "OpInfo", "[", "OpNo", "]", ".", "RegClass", "==", "-", "1", ")", "{", "Register", "Reg", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", ";", "if", "(", "Register", "::", "isVirtualRegister", "(", "Reg", ")", ")", "return", "MRI", ".", "getRegClass", "(", "Reg", ")", ";", "return", "RI", ".", "getPhysRegClass", "(", "Reg", ")", ";", "}", "unsigned", "RCID", "=", "Desc", ".", "OpInfo", "[", "OpNo", "]", ".", "RegClass", ";", "return", "RI", ".", "getRegClass", "(", "RCID", ")", ";", "}", "</s>" ]

[ "Return", "the", "correct", "register", "class", "for", "OpNo", "." ]

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

[]

[ "<s>", "StringRef", "getName", "(", ")", "const", "{", "return", "Name", ";", "}", "</s>" ]

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

[ "PIC16" ]

[]

[ "<s>", "void", "NVPTXAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "if", "(", "static_cast", "<", "NVPTXTargetMachine", "&", ">", "(", "TM", ")", ".", "getDrvInterface", "(", ")", "==", "NVPTX", "::", "CUDA", ")", "emitLineNumberAsDotLoc", "(", "*", "MI", ")", ";", "MCInst", "Inst", ";", "lowerToMCInst", "(", "MI", ",", "Inst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "Inst", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "128", "NVPTX", "NVPTX::CUDA" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "createTeeRISCELFObjectWriter", "(", "OS", ",", "OSABI", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

[ "TeeRISC", "TeeRISC" ]

[]

[ "<s>", "static", "void", "ix86_set_indirect_branch_type", "(", "tree", "fndecl", ")", "{", "if", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "==", "indirect_branch_unset", ")", "{", "tree", "attr", "=", "lookup_attribute", "(", "\"indirect_branch\"", ",", "DECL_ATTRIBUTES", "(", "fndecl", ")", ")", ";", "if", "(", "attr", "!=", "NULL", ")", "{", "tree", "args", "=", "TREE_VALUE", "(", "attr", ")", ";", "if", "(", "args", "==", "NULL", ")", "gcc_unreachable", "(", ")", ";", "tree", "cst", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "cst", ")", ",", "\"keep\"", ")", "==", "0", ")", "cfun", "->", "machine", "->", "indirect_branch_type", "=", "indirect_branch_keep", ";", "else", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "cst", ")", ",", "\"thunk\"", ")", "==", "0", ")", "cfun", "->", "machine", "->", "indirect_branch_type", "=", "indirect_branch_thunk", ";", "else", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "cst", ")", ",", "\"thunk-inline\"", ")", "==", "0", ")", "cfun", "->", "machine", "->", "indirect_branch_type", "=", "indirect_branch_thunk_inline", ";", "else", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "cst", ")", ",", "\"thunk-extern\"", ")", "==", "0", ")", "cfun", "->", "machine", "->", "indirect_branch_type", "=", "indirect_branch_thunk_extern", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "cfun", "->", "machine", "->", "indirect_branch_type", "=", "ix86_indirect_branch", ";", "if", "(", "(", "ix86_cmodel", "==", "CM_LARGE", "||", "ix86_cmodel", "==", "CM_LARGE_PIC", ")", "&&", "(", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "==", "indirect_branch_thunk_extern", ")", "||", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "==", "indirect_branch_thunk", ")", ")", ")", "error", "(", "\"%<-mindirect-branch=%s%> and %<-mcmodel=large%> are not \"", "\"compatible\"", ",", "(", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "==", "indirect_branch_thunk_extern", ")", "?", "\"thunk-extern\"", ":", "\"thunk\"", ")", ")", ";", "if", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "!=", "indirect_branch_keep", "&&", "(", "flag_cf_protection", "&", "CF_RETURN", ")", ")", "error", "(", "\"%<-mindirect-branch%> and %<-fcf-protection%> are not \"", "\"compatible\"", ")", ";", "}", "if", "(", "cfun", "->", "machine", "->", "function_return_type", "==", "indirect_branch_unset", ")", "{", "tree", "attr", "=", "lookup_attribute", "(", "\"function_return\"", ",", "DECL_ATTRIBUTES", "(", "fndecl", ")", ")", ";", "if", "(", "attr", "!=", "NULL", ")", "{", "tree", "args", "=", "TREE_VALUE", "(", "attr", ")", ";", "if", "(", "args", "==", "NULL", ")", "gcc_unreachable", "(", ")", ";", "tree", "cst", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "cst", ")", ",", "\"keep\"", ")", "==", "0", ")", "cfun", "->", "machine", "->", "function_return_type", "=", "indirect_branch_keep", ";", "else", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "cst", ")", ",", "\"thunk\"", ")", "==", "0", ")", "cfun", "->", "machine", "->", "function_return_type", "=", "indirect_branch_thunk", ";", "else", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "cst", ")", ",", "\"thunk-inline\"", ")", "==", "0", ")", "cfun", "->", "machine", "->", "function_return_type", "=", "indirect_branch_thunk_inline", ";", "else", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "cst", ")", ",", "\"thunk-extern\"", ")", "==", "0", ")", "cfun", "->", "machine", "->", "function_return_type", "=", "indirect_branch_thunk_extern", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "cfun", "->", "machine", "->", "function_return_type", "=", "ix86_function_return", ";", "if", "(", "(", "ix86_cmodel", "==", "CM_LARGE", "||", "ix86_cmodel", "==", "CM_LARGE_PIC", ")", "&&", "(", "(", "cfun", "->", "machine", "->", "function_return_type", "==", "indirect_branch_thunk_extern", ")", "||", "(", "cfun", "->", "machine", "->", "function_return_type", "==", "indirect_branch_thunk", ")", ")", ")", "error", "(", "\"%<-mfunction-return=%s%> and %<-mcmodel=large%> are not \"", "\"compatible\"", ",", "(", "(", "cfun", "->", "machine", "->", "function_return_type", "==", "indirect_branch_thunk_extern", ")", "?", "\"thunk-extern\"", ":", "\"thunk\"", ")", ")", ";", "if", "(", "cfun", "->", "machine", "->", "function_return_type", "!=", "indirect_branch_keep", "&&", "(", "flag_cf_protection", "&", "CF_RETURN", ")", ")", "error", "(", "\"%<-mfunction-return%> and %<-fcf-protection%> are not \"", "\"compatible\"", ")", ";", "}", "}", "</s>" ]

[ "Set", "the", "indirect_branch_type", "field", "from", "the", "function", "FNDECL", "." ]

[ "i386", "\"indirect_branch\"", "\"keep\"", "0", "\"thunk\"", "0", "\"thunk-inline\"", "0", "\"thunk-extern\"", "0", "\"%<-mindirect-branch=%s%> and %<-mcmodel=large%> are not \"", "\"compatible\"", "\"thunk-extern\"", "\"thunk\"", "\"%<-mindirect-branch%> and %<-fcf-protection%> are not \"", "\"compatible\"", "\"function_return\"", "\"keep\"", "0", "\"thunk\"", "0", "\"thunk-inline\"", "0", "\"thunk-extern\"", "0", "\"%<-mfunction-return=%s%> and %<-mcmodel=large%> are not \"", "\"compatible\"", "\"thunk-extern\"", "\"thunk\"", "\"%<-mfunction-return%> and %<-fcf-protection%> are not \"", "\"compatible\"" ]

[]

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

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

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

[]

[ "<s>", "bool", "TVMInstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "&", "MI", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "!=", "TVM", "::", "THROW", "||", "Pred", ".", "size", "(", ")", "!=", "2", ")", "{", "return", "false", ";", "}", "assert", "(", "isPredicable", "(", "MI", ")", "&&", "\"Expected predicable instruction\"", ")", ";", "assert", "(", "Pred", "[", "0", "]", ".", "isImm", "(", ")", "&&", "\"Expected immediate for 'Inverted'\"", ")", ";", "assert", "(", "Pred", "[", "1", "]", ".", "isReg", "(", ")", "&&", "\"Expected register for 'Cond'\"", ")", ";", "bool", "Inverted", "=", "Pred", "[", "0", "]", ".", "getImm", "(", ")", ";", "auto", "ErrCode", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "MI", ".", "RemoveOperand", "(", "0", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "Inverted", "?", "TVM", "::", "THROWIFNOT", ":", "TVM", "::", "THROWIF", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "add", "(", "Pred", "[", "1", "]", ")", ".", "add", "(", "ErrCode", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "TVM", "TVM", "TVM::THROW", "2", "\"Expected predicable instruction\"", "0", "\"Expected immediate for 'Inverted'\"", "1", "\"Expected register for 'Cond'\"", "0", "0", "0", "TVM::THROWIFNOT", "TVM::THROWIF", "1" ]

[]

[ "<s>", "static", "tree", "avr_build_builtin_va_list", "(", "void", ")", "{", "avr_adjust_type_node", "(", "&", "ta_type_node", ",", "TAmode", ",", "0", ")", ";", "avr_adjust_type_node", "(", "&", "uta_type_node", ",", "UTAmode", ",", "0", ")", ";", "avr_adjust_type_node", "(", "&", "sat_ta_type_node", ",", "TAmode", ",", "1", ")", ";", "avr_adjust_type_node", "(", "&", "sat_uta_type_node", ",", "UTAmode", ",", "1", ")", ";", "unsigned_long_long_accum_type_node", "=", "uta_type_node", ";", "long_long_accum_type_node", "=", "ta_type_node", ";", "sat_unsigned_long_long_accum_type_node", "=", "sat_uta_type_node", ";", "sat_long_long_accum_type_node", "=", "sat_ta_type_node", ";", "return", "std_build_builtin_va_list", "(", ")", ";", "}", "</s>" ]

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

[ "avr", "0", "0", "1", "1" ]

[]

[ "<s>", "static", "inline", "bool", "offset_9bit_signed_unscaled_p", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "offset", ")", "{", "return", "offset", ">=", "-", "256", "&&", "offset", "<", "256", ";", "}", "</s>" ]

[ "Return", "true", "if", "OFFSET", "is", "a", "signed", "9-bit", "value", "." ]

[ "aarch64", "256", "256" ]

[]

[ "<s>", "unsigned", "PPCFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ",", "bool", "UpdateMF", ",", "bool", "UseEstimate", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "UseEstimate", "?", "MFI", "->", "estimateStackSize", "(", "MF", ")", ":", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "TargetAlign", "=", "getStackAlignment", "(", ")", ";", "unsigned", "MaxAlign", "=", "MFI", "->", "getMaxAlignment", "(", ")", ";", "unsigned", "AlignMask", "=", "std", "::", "max", "(", "MaxAlign", ",", "TargetAlign", ")", "-", "1", ";", "const", "PPCRegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "PPCRegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "bool", "DisableRedZone", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "NoRedZone", ")", ";", "if", "(", "!", "DisableRedZone", "&&", "(", "Subtarget", ".", "isPPC64", "(", ")", "||", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", "||", "FrameSize", "==", "0", ")", "&&", "FrameSize", "<=", "224", "&&", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", "&&", "!", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "if", "(", "UpdateMF", ")", "MFI", "->", "setStackSize", "(", "0", ")", ";", "return", "0", ";", "}", "unsigned", "maxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "unsigned", "minCallFrameSize", "=", "getLinkageSize", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "Subtarget", ".", "isDarwinABI", "(", ")", ")", ";", "maxCallFrameSize", "=", "std", "::", "max", "(", "maxCallFrameSize", ",", "minCallFrameSize", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "(", "maxCallFrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "if", "(", "UpdateMF", ")", "MFI", "->", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "(", "FrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "if", "(", "UpdateMF", ")", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "return", "FrameSize", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "Mips", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_Mips_16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Mips_REL32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Mips_26\"", ",", "0", ",", "26", ",", "0", "}", ",", "{", "\"fixup_Mips_HI16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_LO16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GPREL16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_LITERAL\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOT_Global\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOT_Local\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_PC16\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_Mips_CALL16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GPREL32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Mips_SHIFT5\"", ",", "6", ",", "5", ",", "0", "}", ",", "{", "\"fixup_Mips_SHIFT6\"", ",", "6", ",", "5", ",", "0", "}", ",", "{", "\"fixup_Mips_64\"", ",", "0", ",", "64", ",", "0", "}", ",", "{", "\"fixup_Mips_TLSGD\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOTTPREL\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_TPREL_HI\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_TPREL_LO\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_TLSLDM\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_DTPREL_HI\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_DTPREL_LO\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_Branch_PCRel\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_Mips_GPOFF_HI\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GPOFF_LO\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOT_PAGE\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOT_OFST\"", ",", "0", ",", "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", "." ]

[ "Mips", "Mips::NumTargetFixupKinds", "\"fixup_Mips_16\"", "0", "16", "0", "\"fixup_Mips_32\"", "0", "32", "0", "\"fixup_Mips_REL32\"", "0", "32", "0", "\"fixup_Mips_26\"", "0", "26", "0", "\"fixup_Mips_HI16\"", "0", "16", "0", "\"fixup_Mips_LO16\"", "0", "16", "0", "\"fixup_Mips_GPREL16\"", "0", "16", "0", "\"fixup_Mips_LITERAL\"", "0", "16", "0", "\"fixup_Mips_GOT_Global\"", "0", "16", "0", "\"fixup_Mips_GOT_Local\"", "0", "16", "0", "\"fixup_Mips_PC16\"", "0", "16", "\"fixup_Mips_CALL16\"", "0", "16", "0", "\"fixup_Mips_GPREL32\"", "0", "32", "0", "\"fixup_Mips_SHIFT5\"", "6", "5", "0", "\"fixup_Mips_SHIFT6\"", "6", "5", "0", "\"fixup_Mips_64\"", "0", "64", "0", "\"fixup_Mips_TLSGD\"", "0", "16", "0", "\"fixup_Mips_GOTTPREL\"", "0", "16", "0", "\"fixup_Mips_TPREL_HI\"", "0", "16", "0", "\"fixup_Mips_TPREL_LO\"", "0", "16", "0", "\"fixup_Mips_TLSLDM\"", "0", "16", "0", "\"fixup_Mips_DTPREL_HI\"", "0", "16", "0", "\"fixup_Mips_DTPREL_LO\"", "0", "16", "0", "\"fixup_Mips_Branch_PCRel\"", "0", "16", "\"fixup_Mips_GPOFF_HI\"", "0", "16", "0", "\"fixup_Mips_GPOFF_LO\"", "0", "16", "0", "\"fixup_Mips_GOT_PAGE\"", "0", "16", "0", "\"fixup_Mips_GOT_OFST\"", "0", "16", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "void", "XNCMInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "llvm_unreachable", "(", "\"Cannot store this register to stack slot!\"", ")", ";", "}", "</s>" ]

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

[ "XNCM", "XNCM", "\"Cannot store this register to stack slot!\"" ]

[]

[ "<s>", "Function", "*", "MBlazeIntrinsicInfo", "::", "getDeclaration", "(", "Module", "*", "M", ",", "unsigned", "IntrID", ",", "Type", "*", "*", "Tys", ",", "unsigned", "numTy", ")", "const", "{", "assert", "(", "!", "isOverloaded", "(", "IntrID", ")", "&&", "\"MBlaze intrinsics are not overloaded\"", ")", ";", "AttrListPtr", "AList", "=", "getAttributes", "(", "M", "->", "getContext", "(", ")", ",", "(", "mblazeIntrinsic", "::", "ID", ")", "IntrID", ")", ";", "return", "cast", "<", "Function", ">", "(", "M", "->", "getOrInsertFunction", "(", "getName", "(", "IntrID", ")", ",", "getType", "(", "M", "->", "getContext", "(", ")", ",", "IntrID", ")", ",", "AList", ")", ")", ";", "}", "</s>" ]

[ "Create", "or", "insert", "an", "LLVM", "Function", "declaration", "for", "an", "intrinsic", ",", "and", "return", "it", "." ]

[ "MBlaze", "MBlaze", "\"MBlaze intrinsics are not overloaded\"", "mblazeIntrinsic::ID" ]

[]

[ "<s>", "bool", "Z80Operand", "::", "isToken", "(", ")", "const", "{", "return", "this", "->", "Kind", "==", "k_Token", ";", "}", "</s>" ]

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

[ "Z80", "Z80" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "getLoopAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "JVM" ]

[]

[ "<s>", "static", "MCSymbol", "*", "GetSymbolFromOperand", "(", "const", "MachineOperand", "&", "MO", ",", "AsmPrinter", "&", "AP", ")", "{", "const", "TargetMachine", "&", "TM", "=", "AP", ".", "TM", ";", "Mangler", "*", "Mang", "=", "AP", ".", "Mang", ";", "const", "DataLayout", "*", "DL", "=", "TM", ".", "getDataLayout", "(", ")", ";", "MCContext", "&", "Ctx", "=", "AP", ".", "OutContext", ";", "bool", "isDarwin", "=", "TM", ".", "getTargetTriple", "(", ")", ".", "isOSDarwin", "(", ")", ";", "SmallString", "<", "128", ">", "Name", ";", "StringRef", "Suffix", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "PPCII", "::", "MO_PLT_OR_STUB", ")", "{", "if", "(", "isDarwin", ")", "Suffix", "=", "\"$stub\"", ";", "}", "else", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_FLAG", ")", "Suffix", "=", "\"$non_lazy_ptr\"", ";", "if", "(", "!", "Suffix", ".", "empty", "(", ")", ")", "Name", "+=", "DL", "->", "getPrivateGlobalPrefix", "(", ")", ";", "unsigned", "PrefixLen", "=", "Name", ".", "size", "(", ")", ";", "if", "(", "!", "MO", ".", "isGlobal", "(", ")", ")", "{", "assert", "(", "MO", ".", "isSymbol", "(", ")", "&&", "\"Isn't a symbol reference\"", ")", ";", "Mangler", "::", "getNameWithPrefix", "(", "Name", ",", "MO", ".", "getSymbolName", "(", ")", ",", "*", "DL", ")", ";", "}", "else", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "TM", ".", "getNameWithPrefix", "(", "Name", ",", "GV", ",", "*", "Mang", ")", ";", "}", "unsigned", "OrigLen", "=", "Name", ".", "size", "(", ")", "-", "PrefixLen", ";", "Name", "+=", "Suffix", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "Name", ")", ";", "StringRef", "OrigName", "=", "StringRef", "(", "Name", ")", ".", "substr", "(", "PrefixLen", ",", "OrigLen", ")", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "PPCII", "::", "MO_PLT_OR_STUB", "&&", "isDarwin", ")", "{", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "getMachOMMI", "(", "AP", ")", ".", "getFnStubEntry", "(", "Sym", ")", ";", "if", "(", "StubSym", ".", "getPointer", "(", ")", ")", "return", "Sym", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AP", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "else", "{", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "Ctx", ".", "getOrCreateSymbol", "(", "OrigName", ")", ",", "false", ")", ";", "}", "return", "Sym", ";", "}", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_FLAG", ")", "{", "MachineModuleInfoMachO", "&", "MachO", "=", "getMachOMMI", "(", "AP", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_HIDDEN_FLAG", ")", "?", "MachO", ".", "getHiddenGVStubEntry", "(", "Sym", ")", ":", "MachO", ".", "getGVStubEntry", "(", "Sym", ")", ";", "if", "(", "!", "StubSym", ".", "getPointer", "(", ")", ")", "{", "assert", "(", "MO", ".", "isGlobal", "(", ")", "&&", "\"Extern symbol not handled yet\"", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AP", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "return", "Sym", ";", "}", "return", "Sym", ";", "}", "</s>" ]

[ "Lower", "an", "MO_GlobalAddress", "or", "MO_ExternalSymbol", "operand", "to", "an", "MCSymbol", "." ]

[ "PowerPC", "128", "PPCII::MO_PLT_OR_STUB", "\"$stub\"", "PPCII::MO_NLP_FLAG", "\"$non_lazy_ptr\"", "\"Isn't a symbol reference\"", "PPCII::MO_PLT_OR_STUB", "PPCII::MO_NLP_FLAG", "PPCII::MO_NLP_HIDDEN_FLAG", "\"Extern symbol not handled yet\"" ]

[]

[ "<s>", "void", "MSP430InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlign", "(", "FrameIdx", ")", ")", ";", "if", "(", "RC", "==", "&", "MSP430", "::", "GR16RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV16mr", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "MSP430", "::", "GR8RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV8mr", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Cannot store this register to stack slot!\"", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::GR16RegClass", "MSP430::MOV16mr", "0", "MSP430::GR8RegClass", "MSP430::MOV8mr", "0", "\"Cannot store this register to stack slot!\"" ]

[]

[ "<s>", "bool", "ix86_can_use_return_insn_p", "(", "void", ")", "{", "struct", "ix86_frame", "frame", ";", "if", "(", "!", "reload_completed", "||", "frame_pointer_needed", "||", "cfun", "->", "machine", "->", "func_type", "!=", "TYPE_NORMAL", ")", "return", "0", ";", "if", "(", "crtl", "->", "args", ".", "pops_args", "&&", "crtl", "->", "args", ".", "size", ">=", "32768", ")", "return", "0", ";", "ix86_compute_frame_layout", "(", "&", "frame", ")", ";", "return", "(", "frame", ".", "stack_pointer_offset", "==", "UNITS_PER_WORD", "&&", "(", "frame", ".", "nregs", "+", "frame", ".", "nsseregs", ")", "==", "0", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "it", "is", "appropriate", "to", "emit", "`", "ret", "'", "instructions", "in", "the", "body", "of", "a", "function", ".", "Do", "this", "only", "if", "the", "epilogue", "is", "simple", ",", "needing", "a", "couple", "of", "insns", ".", "Prior", "to", "reloading", ",", "we", "ca", "n't", "tell", "how", "many", "registers", "must", "be", "saved", ",", "so", "return", "0", "then", ".", "Return", "0", "if", "there", "is", "no", "frame", "marker", "to", "de-allocate", "." ]

[ "i386", "0", "32768", "0", "0" ]

[]

[ "<s>", "unsigned", "J2RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "J2", "::", "R14", ";", "}", "</s>" ]

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

[ "J2", "J2", "J2::R14" ]

[]

[ "<s>", "static", "bool", "nvptx_call_insn_is_syscall_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "gcc_checking_assert", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", ";", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", "pat", "=", "SET_SRC", "(", "pat", ")", ";", "gcc_checking_assert", "(", "GET_CODE", "(", "pat", ")", "==", "CALL", "&&", "GET_CODE", "(", "XEXP", "(", "pat", ",", "0", ")", ")", "==", "MEM", ")", ";", "rtx", "addr", "=", "XEXP", "(", "XEXP", "(", "pat", ",", "0", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "SYMBOL_REF", ")", "return", "false", ";", "const", "char", "*", "name", "=", "XSTR", "(", "addr", ",", "0", ")", ";", "return", "(", "!", "strcmp", "(", "name", ",", "\"vprintf\"", ")", "||", "!", "strcmp", "(", "name", ",", "\"*vprintf\"", ")", "||", "!", "strcmp", "(", "name", ",", "\"*malloc\"", ")", "||", "!", "strcmp", "(", "name", ",", "\"*free\"", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "given", "call", "insn", "references", "one", "of", "the", "functions", "provided", "by", "the", "CUDA", "runtime", ":", "malloc", ",", "free", ",", "vprintf", "." ]

[ "nvptx", "0", "0", "0", "0", "0", "0", "\"vprintf\"", "\"*vprintf\"", "\"*malloc\"", "\"*free\"" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MipsTargetStreamer", "&", "TS", "=", "getTargetStreamer", "(", ")", ";", "TS", ".", "setCanHaveModuleDir", "(", "false", ")", ";", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "PrintDebugValueComment", "(", "MI", ",", "OS", ")", ";", "return", ";", "}", "if", "(", "InConstantPool", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "Mips", "::", "CONSTPOOL_ENTRY", ")", "{", "OutStreamer", ".", "EmitDataRegion", "(", "MCDR_DataRegionEnd", ")", ";", "InConstantPool", "=", "false", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "Mips", "::", "CONSTPOOL_ENTRY", ")", "{", "unsigned", "LabelId", "=", "(", "unsigned", ")", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "unsigned", "CPIdx", "=", "(", "unsigned", ")", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "if", "(", "!", "InConstantPool", ")", "{", "OutStreamer", ".", "EmitDataRegion", "(", "MCDR_DataRegion", ")", ";", "InConstantPool", "=", "true", ";", "}", "OutStreamer", ".", "EmitLabel", "(", "GetCPISymbol", "(", "LabelId", ")", ")", ";", "const", "MachineConstantPoolEntry", "&", "MCPE", "=", "MCP", "->", "getConstants", "(", ")", "[", "CPIdx", "]", ";", "if", "(", "MCPE", ".", "isMachineConstantPoolEntry", "(", ")", ")", "EmitMachineConstantPoolValue", "(", "MCPE", ".", "Val", ".", "MachineCPVal", ")", ";", "else", "EmitGlobalConstant", "(", "MCPE", ".", "Val", ".", "ConstVal", ")", ";", "return", ";", "}", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "do", "{", "if", "(", "emitPseudoExpansionLowering", "(", "OutStreamer", ",", "&", "*", "I", ")", ")", "continue", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoReturn", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoReturn64", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoIndirectBranch", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoIndirectBranch64", ")", "{", "emitPseudoIndirectBranch", "(", "OutStreamer", ",", "&", "*", "I", ")", ";", "continue", ";", "}", "if", "(", "I", "->", "isPseudo", "(", ")", "&&", "!", "Subtarget", "->", "inMips16Mode", "(", ")", "&&", "!", "isLongBranchPseudo", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "llvm_unreachable", "(", "\"Pseudo opcode found in EmitInstruction()\"", ")", ";", "MCInst", "TmpInst0", ";", "MCInstLowering", ".", "Lower", "(", "I", ",", "TmpInst0", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "TmpInst0", ")", ";", "}", "while", "(", "(", "++", "I", "!=", "E", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "128", "Mips::CONSTPOOL_ENTRY", "Mips::CONSTPOOL_ENTRY", "0", "1", "Mips::PseudoReturn", "Mips::PseudoReturn64", "Mips::PseudoIndirectBranch", "Mips::PseudoIndirectBranch64", "Mips", "\"Pseudo opcode found in EmitInstruction()\"" ]

[]

[ "<s>", "bool", "h8sx_mergeable_memrefs_p", "(", "rtx", "lhs", ",", "rtx", "rhs", ")", "{", "if", "(", "GET_CODE", "(", "rhs", ")", "==", "MEM", "&&", "GET_CODE", "(", "lhs", ")", "==", "MEM", ")", "{", "rhs", "=", "XEXP", "(", "rhs", ",", "0", ")", ";", "lhs", "=", "XEXP", "(", "lhs", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "rhs", ")", "==", "PRE_INC", "||", "GET_CODE", "(", "rhs", ")", "==", "PRE_DEC", ")", "return", "rtx_equal_p", "(", "XEXP", "(", "rhs", ",", "0", ")", ",", "lhs", ")", ";", "if", "(", "GET_CODE", "(", "lhs", ")", "==", "POST_INC", "||", "GET_CODE", "(", "lhs", ")", "==", "POST_DEC", ")", "return", "rtx_equal_p", "(", "rhs", ",", "XEXP", "(", "lhs", ",", "0", ")", ")", ";", "if", "(", "rtx_equal_p", "(", "rhs", ",", "lhs", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "LHS", "and", "RHS", "are", "memory", "references", "that", "can", "be", "mapped", "to", "the", "same", "h8sx", "assembly", "operand", ".", "LHS", "appears", "as", "the", "destination", "of", "an", "instruction", "and", "RHS", "appears", "as", "a", "source", ".", "Three", "cases", "are", "allowed", ":", "-", "RHS", "is", "@", "+Rn", "or", "@", "-Rn", ",", "LHS", "is", "@", "Rn", "-", "RHS", "is", "@", "Rn", ",", "LHS", "is", "@", "Rn+", "or", "@", "Rn-", "-", "RHS", "and", "LHS", "have", "the", "same", "address", "and", "neither", "has", "side", "effects", "." ]

[ "h8300", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "usesConstantBus", "(", "const", "MCInst", "&", "Inst", ",", "unsigned", "OpIdx", ")", "{", "const", "MCOperand", "&", "MO", "=", "Inst", ".", "getOperand", "(", "OpIdx", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "!", "isInlineConstant", "(", "Inst", ",", "OpIdx", ")", ";", "}", "else", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "auto", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "const", "MCRegisterInfo", "*", "TRI", "=", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "auto", "PReg", "=", "mc2PseudoReg", "(", "Reg", ")", ";", "return", "isSGPR", "(", "PReg", ",", "TRI", ")", "&&", "PReg", "!=", "SGPR_NULL", ";", "}", "else", "{", "return", "true", ";", "}", "}", "</s>" ]

[ "Returns", "true", "if", "this", "operand", "uses", "the", "constant", "bus", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "sh_emit_scc_to_t", "(", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "t_reg", "=", "get_t_reg_rtx", "(", ")", ";", "enum", "rtx_code", "oldcode", "=", "code", ";", "machine_mode", "mode", ";", "switch", "(", "code", ")", "{", "case", "NE", ":", "gcc_unreachable", "(", ")", ";", "case", "LT", ":", "code", "=", "GT", ";", "break", ";", "case", "LE", ":", "code", "=", "GE", ";", "break", ";", "case", "LTU", ":", "code", "=", "GTU", ";", "break", ";", "case", "LEU", ":", "code", "=", "GEU", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "code", "!=", "oldcode", ")", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "mode", "=", "GET_MODE", "(", "op0", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "GET_MODE", "(", "op1", ")", ";", "op0", "=", "force_reg", "(", "mode", ",", "op0", ")", ";", "if", "(", "(", "code", "!=", "EQ", "&&", "code", "!=", "NE", "&&", "(", "op1", "!=", "const0_rtx", "||", "code", "==", "GTU", "||", "code", "==", "GEU", "||", "code", "==", "LTU", "||", "code", "==", "LEU", ")", ")", "||", "(", "mode", "==", "DImode", "&&", "op1", "!=", "const0_rtx", ")", "||", "(", "TARGET_SH2E", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", ")", "op1", "=", "force_reg", "(", "mode", ",", "op1", ")", ";", "sh_emit_set_t_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "t_reg", ",", "gen_rtx_fmt_ee", "(", "code", ",", "SImode", ",", "op0", ",", "op1", ")", ")", ",", "mode", ")", ";", "}", "</s>" ]

[ "Prepare", "the", "operands", "for", "an", "scc", "instruction", ";", "make", "sure", "that", "the", "compare", "has", "been", "done", "and", "the", "result", "is", "in", "T_REG", "." ]

[ "sh" ]

[]

[ "<s>", "enum", "reg_class", "mcore_reload_class", "(", "rtx", "x", ",", "enum", "reg_class", "class", ")", "{", "if", "(", "reg_class_subset_p", "(", "LRW_REGS", ",", "class", ")", "&&", "!", "mcore_r15_operand_p", "(", "x", ")", ")", "return", "LRW_REGS", ";", "return", "class", ";", "}", "</s>" ]

[ "Return", "the", "reg_class", "to", "use", "when", "reloading", "the", "rtx", "X", "into", "the", "class", "CLASS", ".", "If", "X", "is", "too", "complex", "to", "move", "directly", "into", "r15", ",", "prefer", "to", "use", "LRW_REGS", "instead", "." ]

[ "mcore" ]

[]

[ "<s>", "const", "char", "*", "output_move_const_into_data_reg", "(", "rtx", "*", "operands", ")", "{", "int", "i", ";", "i", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "switch", "(", "const_method", "(", "operands", "[", "1", "]", ")", ")", "{", "case", "MVZ", ":", "return", "\"mvsw %1,%0\"", ";", "case", "MVS", ":", "return", "\"mvzw %1,%0\"", ";", "case", "MOVQ", ":", "return", "\"moveq %1,%0\"", ";", "case", "NOTB", ":", "CC_STATUS_INIT", ";", "operands", "[", "1", "]", "=", "GEN_INT", "(", "i", "^", "0xff", ")", ";", "return", "\"moveq %1,%0\\n\\tnot%.b %0\"", ";", "case", "NOTW", ":", "CC_STATUS_INIT", ";", "operands", "[", "1", "]", "=", "GEN_INT", "(", "i", "^", "0xffff", ")", ";", "return", "\"moveq %1,%0\\n\\tnot%.w %0\"", ";", "case", "NEGW", ":", "CC_STATUS_INIT", ";", "return", "\"moveq #-128,%0\\n\\tneg%.w %0\"", ";", "case", "SWAP", ":", "{", "unsigned", "u", "=", "i", ";", "operands", "[", "1", "]", "=", "GEN_INT", "(", "(", "u", "<<", "16", ")", "|", "(", "u", ">>", "16", ")", ")", ";", "return", "\"moveq %1,%0\\n\\tswap %0\"", ";", "}", "case", "MOVL", ":", "return", "\"move%.l %1,%0\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "an", "instruction", "to", "move", "CONST_INT", "OPERANDS", "[", "1", "]", "into", "data", "register", "OPERANDS", "[", "0", "]", "." ]

[ "m68k", "1", "1", "\"mvsw %1,%0\"", "\"mvzw %1,%0\"", "\"moveq %1,%0\"", "1", "0xff", "\"moveq %1,%0\\n\\tnot%.b %0\"", "1", "0xffff", "\"moveq %1,%0\\n\\tnot%.w %0\"", "\"moveq #-128,%0\\n\\tneg%.w %0\"", "1", "16", "16", "\"moveq %1,%0\\n\\tswap %0\"", "\"move%.l %1,%0\"" ]

[]

[ "<s>", "bool", "addPassesToEmitMC", "(", "PassManagerBase", "&", ",", "MCContext", "*", "&", ",", "raw_pwrite_stream", "&", ",", "bool", "=", "true", ")", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Add", "passes", "to", "the", "specified", "pass", "manager", "to", "get", "machine", "code", "emitted", "with", "the", "MCJIT", "." ]

[ "NVPTX" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createPostMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "ScheduleDAGMI", "*", "DAG", "=", "createGenericSchedPostRA", "(", "C", ")", ";", "const", "ARMSubtarget", "&", "ST", "=", "C", "->", "MF", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "hasFusion", "(", ")", ")", "DAG", "->", "addMutation", "(", "createARMMacroFusionDAGMutation", "(", ")", ")", ";", "return", "DAG", ";", "}", "</s>" ]

[ "Similar", "to", "createMachineScheduler", "but", "used", "when", "postRA", "machine", "scheduling", "is", "enabled", "." ]

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

[]

[ "<s>", "void", "HexagonHazardRecognizer", "::", "Reset", "(", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Reset hazard recognizer\\n\"", ")", ";", "Resources", "->", "clearResources", "(", ")", ";", "PacketNum", "=", "0", ";", "UsesDotCur", "=", "nullptr", ";", "DotCurPNum", "=", "-", "1", ";", "RegDefs", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "Reset", "the", "unwind", "opcode", "assembler", "." ]

[ "Hexagon", "Hexagon", "\"Reset hazard recognizer\\n\"", "0", "1" ]

[]

[ "<s>", "static", "void", "add_insn_window", "(", "rtx_insn", "*", "insn", ",", "dispatch_windows", "*", "window_list", ",", "int", "num_uops", ")", "{", "int", "byte_len", "=", "min_insn_size", "(", "insn", ")", ";", "int", "num_insn", "=", "window_list", "->", "num_insn", ";", "int", "imm_size", ";", "sched_insn_info", "*", "window", "=", "window_list", "->", "window", ";", "enum", "dispatch_group", "group", "=", "get_insn_group", "(", "insn", ")", ";", "enum", "insn_path", "path", "=", "get_insn_path", "(", "insn", ")", ";", "int", "num_imm_operand", ";", "int", "num_imm32_operand", ";", "int", "num_imm64_operand", ";", "if", "(", "!", "window_list", "->", "violation", "&&", "group", "!=", "disp_cmp", "&&", "!", "fits_dispatch_window", "(", "insn", ")", ")", "window_list", "->", "violation", "=", "true", ";", "imm_size", "=", "get_num_immediates", "(", "insn", ",", "&", "num_imm_operand", ",", "&", "num_imm32_operand", ",", "&", "num_imm64_operand", ")", ";", "window", "[", "num_insn", "]", ".", "insn", "=", "insn", ";", "window", "[", "num_insn", "]", ".", "byte_len", "=", "byte_len", ";", "window", "[", "num_insn", "]", ".", "group", "=", "group", ";", "window", "[", "num_insn", "]", ".", "path", "=", "path", ";", "window", "[", "num_insn", "]", ".", "imm_bytes", "=", "imm_size", ";", "window_list", "->", "window_size", "+=", "byte_len", ";", "window_list", "->", "num_insn", "=", "num_insn", "+", "1", ";", "window_list", "->", "num_uops", "=", "window_list", "->", "num_uops", "+", "num_uops", ";", "window_list", "->", "imm_size", "+=", "imm_size", ";", "window_list", "->", "num_imm", "+=", "num_imm_operand", ";", "window_list", "->", "num_imm_32", "+=", "num_imm32_operand", ";", "window_list", "->", "num_imm_64", "+=", "num_imm64_operand", ";", "if", "(", "group", "==", "disp_store", ")", "window_list", "->", "num_stores", "+=", "1", ";", "else", "if", "(", "group", "==", "disp_load", "||", "group", "==", "disp_prefetch", ")", "window_list", "->", "num_loads", "+=", "1", ";", "else", "if", "(", "group", "==", "disp_load_store", ")", "{", "window_list", "->", "num_stores", "+=", "1", ";", "window_list", "->", "num_loads", "+=", "1", ";", "}", "}", "</s>" ]

[ "Add", "an", "instruction", "INSN", "with", "NUM_UOPS", "micro-operations", "to", "the", "dispatch", "window", "WINDOW_LIST", "." ]

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

[]

[ "<s>", "FPGASubtarget", "&", "FPGASubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "initializeEnvironment", "(", ")", ";", "initSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "FPGA", "FPGA", "FPGA" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"WebAssembly Fix Function Bitcasts\"", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"WebAssembly Fix Function Bitcasts\"" ]

[]

[ "<s>", "virtual", "void", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "storeRegToStack", "(", "MBB", ",", "MBBI", ",", "SrcReg", ",", "isKill", ",", "FrameIndex", ",", "RC", ",", "TRI", ",", "0", ")", ";", "}", "</s>" ]

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

[ "Mips", "0" ]

[]

[ "<s>", "unsigned", "getExceptionPointerRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "override", "{", "return", "ABI", ".", "IsN64", "(", ")", "?", "Mips", "::", "A0_64", ":", "Mips", "::", "A0", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "address", "on", "entry", "to", "an", "EH", "pad", "." ]

[ "Mips", "Mips::A0_64", "Mips::A0" ]

[]

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

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

[ "X86", "X86::NumTargetFixupKinds", "\"reloc_riprel_4byte\"", "0", "4", "8", "\"reloc_riprel_4byte_movq_load\"", "0", "4", "8", "\"reloc_signed_4byte\"", "0", "4", "8", "0", "\"reloc_global_offset_table\"", "0", "4", "8", "0", "\"reloc_global_offset_table8\"", "0", "8", "8", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "int", "frv_class_max_nregs", "(", "enum", "reg_class", "class", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "class", "==", "ACCG_REGS", ")", "return", "GET_MODE_SIZE", "(", "mode", ")", ";", "else", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "A", "C", "expression", "for", "the", "maximum", "number", "of", "consecutive", "registers", "of", "class", "RCLASS", "needed", "to", "hold", "a", "value", "of", "mode", "MODE", ".", "This", "is", "closely", "related", "to", "the", "macro", "`", "HARD_REGNO_NREGS", "'", ".", "In", "fact", ",", "the", "value", "of", "the", "macro", "`", "CLASS_MAX_NREGS", "(", "RCLASS", ",", "MODE", ")", "'", "should", "be", "the", "maximum", "value", "of", "`", "HARD_REGNO_NREGS", "(", "REGNO", ",", "MODE", ")", "'", "for", "all", "REGNO", "values", "in", "the", "class", "RCLASS", ".", "This", "macro", "helps", "control", "the", "handling", "of", "multiple-word", "values", "in", "the", "reload", "pass", ".", "This", "declaration", "is", "required", "." ]

[ "frv", "1" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"MCS51 DAG->DAG Instruction Selection\"", ";", "}", "</s>" ]

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

[ "MCS51", "\"MCS51 DAG->DAG Instruction Selection\"" ]

[]

[ "<s>", "static", "void", "aarch64_sve_expand_vector_init_insert_elems", "(", "rtx", "target", ",", "const", "rtx_vector_builder", "&", "builder", ",", "int", "nelts_reqd", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "scalar_mode", "elem_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "struct", "expand_operand", "ops", "[", "2", "]", ";", "enum", "insn_code", "icode", "=", "optab_handler", "(", "vec_duplicate_optab", ",", "mode", ")", ";", "gcc_assert", "(", "icode", "!=", "CODE_FOR_nothing", ")", ";", "create_output_operand", "(", "&", "ops", "[", "0", "]", ",", "target", ",", "mode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "1", "]", ",", "builder", ".", "elt", "(", "nelts_reqd", "-", "1", ")", ",", "elem_mode", ")", ";", "expand_insn", "(", "icode", ",", "2", ",", "ops", ")", ";", "int", "ndups", "=", "builder", ".", "count_dups", "(", "nelts_reqd", "-", "1", ",", "-", "1", ",", "-", "1", ")", ";", "for", "(", "int", "i", "=", "nelts_reqd", "-", "ndups", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "emit_insr", "(", "target", ",", "builder", ".", "elt", "(", "i", ")", ")", ";", "}", "</s>" ]

[ "Subroutine", "of", "aarch64_sve_expand_vector_init", ".", "Works", "as", "follows", ":", "(", "a", ")", "Initialize", "TARGET", "by", "broadcasting", "element", "NELTS_REQD", "-", "1", "of", "BUILDER", ".", "(", "b", ")", "Skip", "trailing", "elements", "from", "BUILDER", ",", "which", "are", "the", "same", "as", "element", "NELTS_REQD", "-", "1", ".", "(", "c", ")", "Insert", "earlier", "elements", "in", "reverse", "order", "in", "TARGET", "using", "insr", "." ]

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

[]

[ "<s>", "const", "TargetRegisterClass", "*", "MipsRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "Subtarget", ".", "isABI_N64", "(", ")", "?", "&", "Mips", "::", "GPR64RegClass", ":", "&", "Mips", "::", "GPR32RegClass", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::GPR64RegClass", "Mips::GPR32RegClass" ]

[]

[ "<s>", "void", "rs6000_expand_vector_set", "(", "rtx", "target", ",", "rtx", "val", ",", "int", "elt", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "enum", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "rtx", "reg", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "mask", ",", "mem", ",", "x", ";", "int", "width", "=", "GET_MODE_SIZE", "(", "inner_mode", ")", ";", "int", "i", ";", "mem", "=", "assign_stack_temp", "(", "mode", ",", "GET_MODE_SIZE", "(", "inner_mode", ")", ",", "0", ")", ";", "emit_move_insn", "(", "adjust_address_nv", "(", "mem", ",", "inner_mode", ",", "0", ")", ",", "val", ")", ";", "x", "=", "gen_rtx_UNSPEC", "(", "VOIDmode", ",", "gen_rtvec", "(", "1", ",", "const0_rtx", ")", ",", "UNSPEC_LVE", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "mem", ")", ",", "x", ")", ")", ")", ";", "mask", "=", "gen_rtx_PARALLEL", "(", "V16QImode", ",", "rtvec_alloc", "(", "16", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "16", ";", "++", "i", ")", "XVECEXP", "(", "mask", ",", "0", ",", "i", ")", "=", "GEN_INT", "(", "i", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "width", ";", "++", "i", ")", "XVECEXP", "(", "mask", ",", "0", ",", "elt", "*", "width", "+", "i", ")", "=", "GEN_INT", "(", "i", "+", "0x10", ")", ";", "x", "=", "gen_rtx_CONST_VECTOR", "(", "V16QImode", ",", "XVEC", "(", "mask", ",", "0", ")", ")", ";", "x", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "target", ",", "reg", ",", "force_reg", "(", "V16QImode", ",", "x", ")", ")", ",", "UNSPEC_VPERM", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "x", ")", ")", ";", "}", "</s>" ]

[ "Set", "field", "ELT_RTX", "of", "TARGET", "to", "VAL", "." ]

[ "rs6000", "0", "0", "1", "2", "16", "0", "16", "0", "0", "0", "0x10", "0", "3" ]

[]

[ "<s>", "void", "NVPTXTargetStreamer", "::", "changeSection", "(", "const", "MCSection", "*", "CurSection", ",", "MCSection", "*", "Section", ",", "const", "MCExpr", "*", "SubSection", ",", "raw_ostream", "&", "OS", ")", "{", "assert", "(", "!", "SubSection", "&&", "\"SubSection is not null!\"", ")", ";", "const", "MCObjectFileInfo", "*", "FI", "=", "getStreamer", "(", ")", ".", "getContext", "(", ")", ".", "getObjectFileInfo", "(", ")", ";", "if", "(", "isDwarfSection", "(", "FI", ",", "CurSection", ")", ")", "OS", "<<", "\"//\\t}\\n\"", ";", "if", "(", "isDwarfSection", "(", "FI", ",", "Section", ")", ")", "{", "for", "(", "const", "std", "::", "string", "&", "S", ":", "DwarfFiles", ")", "getStreamer", "(", ")", ".", "EmitRawText", "(", "S", ".", "data", "(", ")", ")", ";", "DwarfFiles", ".", "clear", "(", ")", ";", "OS", "<<", "\"//\\t.section\"", ";", "Section", "->", "PrintSwitchToSection", "(", "*", "getStreamer", "(", ")", ".", "getContext", "(", ")", ".", "getAsmInfo", "(", ")", ",", "FI", "->", "getTargetTriple", "(", ")", ",", "OS", ",", "SubSection", ")", ";", "OS", "<<", "\"//\\t{\\n\"", ";", "}", "}", "</s>" ]

[ "Update", "streamer", "for", "a", "new", "active", "section", "." ]

[ "NVPTX", "NVPTX", "\"SubSection is not null!\"", "\"//\\t}\\n\"", "\"//\\t.section\"", "\"//\\t{\\n\"" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "unsigned", "AArch64AsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "AArch64Operand", "&", "Op", "=", "static_cast", "<", "AArch64Operand", "&", ">", "(", "AsmOp", ")", ";", "int64_t", "ExpectedVal", ";", "switch", "(", "Kind", ")", "{", "default", ":", "return", "Match_InvalidOperand", ";", "case", "MCK__HASH_0", ":", "ExpectedVal", "=", "0", ";", "break", ";", "case", "MCK__HASH_1", ":", "ExpectedVal", "=", "1", ";", "break", ";", "case", "MCK__HASH_12", ":", "ExpectedVal", "=", "12", ";", "break", ";", "case", "MCK__HASH_16", ":", "ExpectedVal", "=", "16", ";", "break", ";", "case", "MCK__HASH_2", ":", "ExpectedVal", "=", "2", ";", "break", ";", "case", "MCK__HASH_24", ":", "ExpectedVal", "=", "24", ";", "break", ";", "case", "MCK__HASH_3", ":", "ExpectedVal", "=", "3", ";", "break", ";", "case", "MCK__HASH_32", ":", "ExpectedVal", "=", "32", ";", "break", ";", "case", "MCK__HASH_4", ":", "ExpectedVal", "=", "4", ";", "break", ";", "case", "MCK__HASH_48", ":", "ExpectedVal", "=", "48", ";", "break", ";", "case", "MCK__HASH_6", ":", "ExpectedVal", "=", "6", ";", "break", ";", "case", "MCK__HASH_64", ":", "ExpectedVal", "=", "64", ";", "break", ";", "case", "MCK__HASH_8", ":", "ExpectedVal", "=", "8", ";", "break", ";", "}", "if", "(", "!", "Op", ".", "isImm", "(", ")", ")", "return", "Match_InvalidOperand", ";", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getImm", "(", ")", ")", ";", "if", "(", "!", "CE", ")", "return", "Match_InvalidOperand", ";", "if", "(", "CE", "->", "getValue", "(", ")", "==", "ExpectedVal", ")", "return", "Match_Success", ";", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "0", "1", "12", "16", "2", "24", "3", "32", "4", "48", "6", "64", "8" ]

[]

[ "<s>", "bool", "SparcAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "O", "<<", "'['", ";", "printMemOperand", "(", "MI", ",", "OpNo", ")", ";", "O", "<<", "']'", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "MipsConstantIslands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "MF", "=", "&", "mf", ";", "MCP", "=", "mf", ".", "getConstantPool", "(", ")", ";", "STI", "=", "&", "mf", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"constant island machine function \"", "<<", "\"\\n\"", ")", ";", "if", "(", "!", "STI", "->", "inMips16Mode", "(", ")", "||", "!", "MipsSubtarget", "::", "useConstantIslands", "(", ")", ")", "{", "return", "false", ";", "}", "TII", "=", "(", "const", "Mips16InstrInfo", "*", ")", "STI", "->", "getInstrInfo", "(", ")", ";", "MFI", "=", "MF", "->", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"constant island processing \"", "<<", "\"\\n\"", ")", ";", "if", "(", "!", "PrescannedForConstants", ")", "prescanForConstants", "(", ")", ";", "HasFarJump", "=", "false", ";", "MF", "->", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "CPEMIs", ";", "if", "(", "!", "MCP", "->", "isEmpty", "(", ")", ")", "doInitialPlacement", "(", "CPEMIs", ")", ";", "initPICLabelUId", "(", "CPEMIs", ".", "size", "(", ")", ")", ";", "initializeFunctionInfo", "(", "CPEMIs", ")", ";", "CPEMIs", ".", "clear", "(", ")", ";", "LLVM_DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "MadeChange", "|=", "removeUnusedCPEntries", "(", ")", ";", "unsigned", "NoCPIters", "=", "0", ",", "NoBRIters", "=", "0", ";", "(", "void", ")", "NoBRIters", ";", "while", "(", "true", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Beginning CP iteration #\"", "<<", "NoCPIters", "<<", "'\\n'", ")", ";", "bool", "CPChange", "=", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CPUsers", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "CPChange", "|=", "handleConstantPoolUser", "(", "i", ")", ";", "if", "(", "CPChange", "&&", "++", "NoCPIters", ">", "30", ")", "report_fatal_error", "(", "\"Constant Island pass failed to converge!\"", ")", ";", "LLVM_DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "NewWaterList", ".", "clear", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Beginning BR iteration #\"", "<<", "NoBRIters", "<<", "'\\n'", ")", ";", "bool", "BRChange", "=", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ImmBranches", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BRChange", "|=", "fixupImmediateBr", "(", "ImmBranches", "[", "i", "]", ")", ";", "if", "(", "BRChange", "&&", "++", "NoBRIters", ">", "30", ")", "report_fatal_error", "(", "\"Branch Fix Up pass failed to converge!\"", ")", ";", "LLVM_DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "if", "(", "!", "CPChange", "&&", "!", "BRChange", ")", "break", ";", "MadeChange", "=", "true", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "'\\n'", ";", "dumpBBs", "(", ")", ")", ";", "BBInfo", ".", "clear", "(", ")", ";", "WaterList", ".", "clear", "(", ")", ";", "CPUsers", ".", "clear", "(", ")", ";", "CPEntries", ".", "clear", "(", ")", ";", "ImmBranches", ".", "clear", "(", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "\"constant island machine function \"", "\"\\n\"", "Mips", "Mips", "Mips", "Mips", "\"constant island processing \"", "\"\\n\"", "0", "0", "\"Beginning CP iteration #\"", "0", "30", "\"Constant Island pass failed to converge!\"", "\"Beginning BR iteration #\"", "0", "30", "\"Branch Fix Up pass failed to converge!\"" ]

[]

[ "<s>", "bool", "R600ClauseMergePass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "R600Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "R600Subtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "LatestCFAlu", "=", "E", ";", "while", "(", "I", "!=", "E", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", "++", ";", "if", "(", "(", "!", "TII", "->", "canBeConsideredALU", "(", "MI", ")", "&&", "!", "isCFAlu", "(", "MI", ")", ")", "||", "TII", "->", "mustBeLastInClause", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "LatestCFAlu", "=", "E", ";", "if", "(", "!", "isCFAlu", "(", "MI", ")", ")", "continue", ";", "cleanPotentialDisabledCFAlu", "(", "MI", ")", ";", "if", "(", "LatestCFAlu", "!=", "E", "&&", "mergeIfPossible", "(", "*", "LatestCFAlu", ",", "MI", ")", ")", "{", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "else", "{", "assert", "(", "MI", ".", "getOperand", "(", "8", ")", ".", "getImm", "(", ")", "&&", "\"CF ALU instruction disabled\"", ")", ";", "LatestCFAlu", "=", "MI", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "R600", "R600", "8", "\"CF ALU instruction disabled\"" ]

[]

[ "<s>", "mips_va_start", "(", "valist", ",", "nextarg", ")", "{", "\\", "if", "(", "TARGET_MIPS16", ")", "\\", "sorry", "(", "\"mips16 function profiling\"", ")", ";", "\\", "fprintf", "(", "FILE", ",", "\"\\t.set\\tnoat\\n\"", ")", ";", "\\", "fprintf", "(", "FILE", ",", "\"\\tmove\\t%s,%s\\t\\t# save current return address\\n\"", ",", "\\", "reg_names", "[", "GP_REG_FIRST", "+", "1", "]", ",", "reg_names", "[", "GP_REG_FIRST", "+", "31", "]", ")", ";", "\\", "if", "(", "!", "TARGET_NEWABI", ")", "\\", "{", "\\", "fprintf", "(", "FILE", ",", "\\", "\"\\t%s\\t%s,%s,%d\\t\\t# _mcount pops 2 words from stack\\n\"", ",", "\\", "TARGET_64BIT", "?", "\"dsubu\"", ":", "\"subu\"", ",", "\\", "reg_names", "[", "STACK_POINTER_REGNUM", "]", ",", "\\", "reg_names", "[", "STACK_POINTER_REGNUM", "]", ",", "\\", "Pmode", "==", "DImode", "?", "16", ":", "8", ")", ";", "\\", "}", "\\", "fprintf", "(", "FILE", ",", "\"\\tjal\\t_mcount\\n\"", ")", ";", "\\", "fprintf", "(", "FILE", ",", "\"\\t.set\\tat\\n\"", ")", ";", "\\", "}", "</s>" ]

[ "Implement", "va_start", "." ]

[ "mips", "\"mips16 function profiling\"", "\"\\t.set\\tnoat\\n\"", "\"\\tmove\\t%s,%s\\t\\t# save current return address\\n\"", "1", "31", "\"\\t%s\\t%s,%s,%d\\t\\t# _mcount pops 2 words from stack\\n\"", "\"dsubu\"", "\"subu\"", "16", "8", "\"\\tjal\\t_mcount\\n\"", "\"\\t.set\\tat\\n\"" ]

[]

[ "<s>", "bool", "ARM64TargetLowering", "::", "isDesirableToCommuteWithShift", "(", "const", "SDNode", "*", "N", ")", "const", "{", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "AND", "&&", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i64", ")", "&&", "isa", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "1", ")", ")", ")", "{", "uint64_t", "TruncMask", "=", "N", "->", "getConstantOperandVal", "(", "1", ")", ";", "if", "(", "isMask_64", "(", "TruncMask", ")", "&&", "N", "->", "getOperand", "(", "0", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SRL", "&&", "isa", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "0", ")", "->", "getOperand", "(", "1", ")", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "move", "this", "shift", "by", "a", "constant", "amount", "through", "its", "operand", ",", "adjusting", "any", "immediate", "operands", "as", "necessary", "to", "preserve", "semantics", "." ]

[ "ARM64", "ARM64", "0", "ISD::AND", "MVT::i32", "MVT::i64", "1", "1", "0", "ISD::SRL", "0", "1" ]

[]

[ "<s>", "void", "ThumbRegisterInfo", "::", "emitLoadConstPool", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "DebugLoc", "dl", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "int", "Val", ",", "ARMCC", "::", "CondCodes", "Pred", ",", "unsigned", "PredReg", ",", "unsigned", "MIFlags", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "STI", ".", "isThumb1Only", "(", ")", ")", "{", "assert", "(", "(", "isARMLowRegister", "(", "DestReg", ")", "||", "isVirtualRegister", "(", "DestReg", ")", ")", "&&", "\"Thumb1 does not have ldr to high register\"", ")", ";", "return", "emitThumb1LoadConstPool", "(", "MBB", ",", "MBBI", ",", "dl", ",", "DestReg", ",", "SubIdx", ",", "Val", ",", "Pred", ",", "PredReg", ",", "MIFlags", ")", ";", "}", "return", "emitThumb2LoadConstPool", "(", "MBB", ",", "MBBI", ",", "dl", ",", "DestReg", ",", "SubIdx", ",", "Val", ",", "Pred", ",", "PredReg", ",", "MIFlags", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARMCC::CondCodes", "ARM", "ARM", "ARM", "\"Thumb1 does not have ldr to high register\"" ]

[]

[ "<s>", "bool", "SystemZAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "SystemZInstPrinter", "::", "printAddress", "(", "MAI", ",", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", ",", "MI", "->", "getOperand", "(", "OpNo", "+", "1", ")", ".", "getImm", "(", ")", ",", "MI", "->", "getOperand", "(", "OpNo", "+", "2", ")", ".", "getReg", "(", ")", ",", "OS", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "1", "2" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isIgnorableUse", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "return", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "EXEC", "&&", "MO", ".", "isImplicit", "(", ")", "&&", "isVALU", "(", "*", "MO", ".", "getParent", "(", ")", ")", ";", "}", "</s>" ]

[ "Given", "MO", "is", "a", "PhysReg", "use", "return", "if", "it", "can", "be", "ignored", "for", "the", "purpose", "of", "instruction", "rematerialization", "or", "sinking", "." ]

[ "AMDGPU", "SI", "AMDGPU::EXEC" ]

[]

[ "<s>", "static", "int", "fast_interrupt_p", "(", "tree", "node", "ATTRIBUTE_UNUSED", ")", "{", "tree", "list", "=", "M32C_ATTRIBUTES", "(", "node", ")", ";", "while", "(", "list", ")", "{", "if", "(", "is_attribute_p", "(", "\"fast_interrupt\"", ",", "TREE_PURPOSE", "(", "list", ")", ")", ")", "return", "1", ";", "list", "=", "TREE_CHAIN", "(", "list", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Returns", "TRUE", "if", "the", "given", "tree", "has", "the", "``", "fast_interrupt", "''", "attribute", "." ]

[ "m32c", "\"fast_interrupt\"", "1", "0" ]

[]

[ "<s>", "static", "rtx", "arc_get_ccfsm_cond", "(", "struct", "arc_ccfsm", "*", "statep", ",", "bool", "reverse", ")", "{", "rtx", "cond", "=", "statep", "->", "cond", ";", "int", "raw_cc", "=", "get_arc_condition_code", "(", "cond", ")", ";", "if", "(", "reverse", ")", "raw_cc", "=", "ARC_INVERSE_CONDITION_CODE", "(", "raw_cc", ")", ";", "if", "(", "statep", "->", "cc", "==", "raw_cc", ")", "return", "copy_rtx", "(", "cond", ")", ";", "gcc_assert", "(", "ARC_INVERSE_CONDITION_CODE", "(", "raw_cc", ")", "==", "statep", "->", "cc", ")", ";", "machine_mode", "ccm", "=", "GET_MODE", "(", "XEXP", "(", "cond", ",", "0", ")", ")", ";", "enum", "rtx_code", "code", "=", "reverse_condition", "(", "GET_CODE", "(", "cond", ")", ")", ";", "if", "(", "code", "==", "UNKNOWN", "||", "ccm", "==", "CC_FP_GTmode", "||", "ccm", "==", "CC_FP_GEmode", ")", "code", "=", "reverse_condition_maybe_unordered", "(", "GET_CODE", "(", "cond", ")", ")", ";", "return", "gen_rtx_fmt_ee", "(", "code", ",", "GET_MODE", "(", "cond", ")", ",", "copy_rtx", "(", "XEXP", "(", "cond", ",", "0", ")", ")", ",", "copy_rtx", "(", "XEXP", "(", "cond", ",", "1", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "a", "copy", "of", "COND", "from", "*", "STATEP", ",", "inverted", "if", "that", "is", "indicated", "by", "the", "CC", "field", "of", "*", "STATEP", "." ]

[ "arc", "0", "0", "1" ]

[]

[ "<s>", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "override", "{", "return", "&", "DL", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "Sparc" ]

[]

[ "<s>", "void", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "override", "{", "storeRegToStack", "(", "MBB", ",", "MBBI", ",", "SrcReg", ",", "isKill", ",", "FrameIndex", ",", "RC", ",", "TRI", ",", "0", ")", ";", "}", "</s>" ]

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

[ "Mips", "0" ]

[]

[ "<s>", "SDValue", "LEGTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unimplemented operand\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "LEG", "LEG", "\"Unimplemented operand\"", "ISD::GlobalAddress" ]

[]

[ "<s>", "void", "s390_expand_cs", "(", "machine_mode", "mode", ",", "rtx", "btarget", ",", "rtx", "vtarget", ",", "rtx", "mem", ",", "rtx", "cmp", ",", "rtx", "new_rtx", ",", "bool", "is_weak", ")", "{", "switch", "(", "mode", ")", "{", "case", "TImode", ":", "case", "DImode", ":", "case", "SImode", ":", "s390_expand_cs_tdsi", "(", "mode", ",", "btarget", ",", "vtarget", ",", "mem", ",", "cmp", ",", "new_rtx", ",", "is_weak", ")", ";", "break", ";", "case", "HImode", ":", "case", "QImode", ":", "s390_expand_cs_hqi", "(", "mode", ",", "btarget", ",", "vtarget", ",", "mem", ",", "cmp", ",", "new_rtx", ",", "is_weak", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Expand", "an", "atomic", "compare", "and", "swap", "operation", ".", "MEM", "is", "the", "memory", "location", ",", "CMP", "the", "old", "value", "to", "compare", "MEM", "with", "and", "NEW_RTX", "the", "value", "to", "set", "if", "CMP", "==", "MEM", "." ]

[ "s390" ]

[]

[ "<s>", "bool", "SystemZTargetLowering", "::", "isLegalICmpImmediate", "(", "int64_t", "Imm", ")", "const", "{", "return", "isInt", "<", "32", ">", "(", "Imm", ")", "||", "isUInt", "<", "32", ">", "(", "Imm", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "immediate", "is", "legal", "icmp", "immediate", ",", "that", "is", "the", "target", "has", "icmp", "instructions", "which", "can", "compare", "a", "register", "against", "the", "immediate", "without", "having", "to", "materialize", "the", "immediate", "into", "a", "register", "." ]

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

[]

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

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

[ "Videocore", "0", "\"RelaxInstruction() unimplemented\"" ]

[]

[ "<s>", "void", "F2003fPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createF2003fFiMalkrzPass", "(", ")", ")", ";", "}", "</s>" ]

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

[ "F2003f", "F2003f", "F2003f" ]

[]

[ "<s>", "unsigned", "X86TTIImpl", "::", "getScalarizationOverhead", "(", "Type", "*", "Ty", ",", "const", "APInt", "&", "DemandedElts", ",", "bool", "Insert", ",", "bool", "Extract", ")", "{", "auto", "*", "VecTy", "=", "cast", "<", "VectorType", ">", "(", "Ty", ")", ";", "unsigned", "Cost", "=", "0", ";", "if", "(", "Insert", ")", "{", "std", "::", "pair", "<", "int", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "MVT", "MScalarTy", "=", "LT", ".", "second", ".", "getScalarType", "(", ")", ";", "if", "(", "(", "MScalarTy", "==", "MVT", "::", "i16", "&&", "ST", "->", "hasSSE2", "(", ")", ")", "||", "(", "MScalarTy", ".", "isInteger", "(", ")", "&&", "ST", "->", "hasSSE41", "(", ")", ")", "||", "(", "MScalarTy", "==", "MVT", "::", "f32", "&&", "ST", "->", "hasSSE41", "(", ")", ")", ")", "{", "if", "(", "LT", ".", "second", ".", "getSizeInBits", "(", ")", "<=", "128", ")", "{", "Cost", "+=", "BaseT", "::", "getScalarizationOverhead", "(", "Ty", ",", "DemandedElts", ",", "Insert", ",", "false", ")", ";", "}", "else", "{", "unsigned", "NumSubVecs", "=", "LT", ".", "second", ".", "getSizeInBits", "(", ")", "/", "128", ";", "Cost", "+=", "(", "PowerOf2Ceil", "(", "NumSubVecs", ")", "-", "1", ")", "*", "LT", ".", "first", ";", "Cost", "+=", "DemandedElts", ".", "countPopulation", "(", ")", ";", "if", "(", "MScalarTy", "==", "MVT", "::", "f32", ")", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "VecTy", "->", "getNumElements", "(", ")", ";", "i", "<", "e", ";", "i", "+=", "4", ")", "if", "(", "DemandedElts", "[", "i", "]", ")", "Cost", "--", ";", "}", "}", "else", "if", "(", "LT", ".", "second", ".", "isVector", "(", ")", ")", "{", "if", "(", "Ty", "->", "isIntOrIntVectorTy", "(", ")", ")", "Cost", "+=", "DemandedElts", ".", "countPopulation", "(", ")", ";", "unsigned", "NumElts", "=", "LT", ".", "second", ".", "getVectorNumElements", "(", ")", ";", "unsigned", "Pow2Elts", "=", "PowerOf2Ceil", "(", "VecTy", "->", "getNumElements", "(", ")", ")", ";", "Cost", "+=", "(", "std", "::", "min", "<", "unsigned", ">", "(", "NumElts", ",", "Pow2Elts", ")", "-", "1", ")", "*", "LT", ".", "first", ";", "}", "}", "if", "(", "Extract", ")", "Cost", "+=", "BaseT", "::", "getScalarizationOverhead", "(", "Ty", ",", "DemandedElts", ",", "false", ",", "Extract", ")", ";", "return", "Cost", ";", "}", "</s>" ]

[ "Estimate", "the", "overhead", "of", "scalarizing", "an", "instruction", "." ]

[ "X86", "X86", "0", "MVT::i16", "MVT::f32", "128", "128", "1", "MVT::f32", "0", "4", "1" ]

[]

[ "<s>", "bool", "WebAssemblyExceptionInfo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Exception Info Calculation **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "releaseMemory", "(", ")", ";", "auto", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "auto", "&", "MDF", "=", "getAnalysis", "<", "MachineDominanceFrontier", ">", "(", ")", ";", "recalculate", "(", "MDT", ",", "MDF", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Exception Info Calculation **********\\n\"", "\"********** Function: \"" ]

[]