Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "bool", "arm_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "GET_MODE_CLASS", "(", "mode2", ")", ")", "return", "true", ";", "if", "(", "(", "TARGET_NEON", "&&", "(", "VALID_NEON_DREG_MODE", "(", "mode1", ")", "||", "VALID_NEON_QREG_MODE", "(", "mode1", ")", "||", "VALID_NEON_STRUCT_MODE", "(", "mode1", ")", ")", "&&", "(", "VALID_NEON_DREG_MODE", "(", "mode2", ")", "||", "VALID_NEON_QREG_MODE", "(", "mode2", ")", "||", "VALID_NEON_STRUCT_MODE", "(", "mode2", ")", ")", ")", "||", "(", "TARGET_HAVE_MVE", "&&", "(", "VALID_MVE_MODE", "(", "mode1", ")", "||", "VALID_MVE_STRUCT_MODE", "(", "mode1", ")", ")", "&&", "(", "VALID_MVE_MODE", "(", "mode2", ")", "||", "VALID_MVE_STRUCT_MODE", "(", "mode2", ")", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "MODES_TIEABLE_P", "." ]

[ "arm" ]

[]

[ "<s>", "rtx", "get_unaligned_address", "(", "rtx", "ref", ")", "{", "rtx", "base", ";", "HOST_WIDE_INT", "offset", "=", "0", ";", "gcc_assert", "(", "MEM_P", "(", "ref", ")", ")", ";", "if", "(", "reload_in_progress", ")", "{", "base", "=", "find_replacement", "(", "&", "XEXP", "(", "ref", ",", "0", ")", ")", ";", "gcc_assert", "(", "memory_address_p", "(", "GET_MODE", "(", "ref", ")", ",", "base", ")", ")", ";", "}", "else", "base", "=", "XEXP", "(", "ref", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "offset", "+=", "INTVAL", "(", "XEXP", "(", "base", ",", "1", ")", ")", ",", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "return", "plus_constant", "(", "Pmode", ",", "base", ",", "offset", ")", ";", "}", "</s>" ]

[ "Similar", ",", "but", "just", "get", "the", "address", ".", "Handle", "the", "two", "reload", "cases", ".", "Add", "EXTRA_OFFSET", "to", "the", "address", "we", "return", "." ]

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

[]

[ "<s>", "bool", "SIInstrInfo", "::", "mayReadEXEC", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "isMetaInstruction", "(", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "isCopyLike", "(", ")", ")", "{", "if", "(", "!", "RI", ".", "isSGPRReg", "(", "MRI", ",", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "return", "true", ";", "return", "MI", ".", "readsRegister", "(", "AMDGPU", "::", "EXEC", ",", "&", "RI", ")", ";", "}", "if", "(", "MI", ".", "isCall", "(", ")", ")", "return", "true", ";", "if", "(", "!", "isTargetSpecificOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "return", "true", ";", "return", "!", "isSALU", "(", "MI", ")", "||", "MI", ".", "readsRegister", "(", "AMDGPU", "::", "EXEC", ",", "&", "RI", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "could", "potentially", "depend", "on", "the", "value", "of", "exec", "." ]

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

[]

[ "<s>", "bool", "TVMFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

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

[ "TVM", "TVM" ]

[]

[ "<s>", "static", "int", "bpf_core_is_maybe_aggregate_access", "(", "tree", "expr", ")", "{", "enum", "tree_code", "code", "=", "TREE_CODE", "(", "expr", ")", ";", "if", "(", "code", "==", "COMPONENT_REF", "||", "code", "==", "ARRAY_REF", ")", "return", "1", ";", "if", "(", "code", "==", "ADDR_EXPR", ")", "return", "bpf_core_is_maybe_aggregate_access", "(", "TREE_OPERAND", "(", "expr", ",", "0", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "whether", "EXPR", "could", "access", "some", "aggregate", "data", "structure", "that", "BPF", "CO-RE", "support", "needs", "to", "know", "about", "." ]

[ "bpf", "1", "0", "0" ]

[]

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

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "bool", "Mips16FrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</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", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "NodeType", "*", "getEntryNode", "(", "const", "agraph", "&", "G", ")", "{", "return", "G", ".", "Blocks", ".", "front", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "token", "chain", "corresponding", "to", "the", "entry", "of", "the", "function", "." ]

[ "Patmos" ]

[]

[ "<s>", "static", "int", "avr_hregs_split_reg", "(", "HARD_REG_SET", "*", "set", ")", "{", "for", "(", "int", "regno", "=", "0", ";", "regno", "<", "32", ";", "regno", "++", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "*", "set", ",", "regno", ")", ")", "{", "if", "(", "AVR_HAVE_RAMPX", "&&", "(", "REG_X", "==", "regno", "||", "REG_X", "+", "1", "==", "regno", ")", "&&", "TEST_HARD_REG_BIT", "(", "*", "set", ",", "REG_X", ")", "&&", "TEST_HARD_REG_BIT", "(", "*", "set", ",", "REG_X", "+", "1", ")", ")", "continue", ";", "if", "(", "AVR_HAVE_RAMPY", "&&", "!", "frame_pointer_needed", "&&", "(", "REG_Y", "==", "regno", "||", "REG_Y", "+", "1", "==", "regno", ")", "&&", "TEST_HARD_REG_BIT", "(", "*", "set", ",", "REG_Y", ")", "&&", "TEST_HARD_REG_BIT", "(", "*", "set", ",", "REG_Y", "+", "1", ")", ")", "continue", ";", "if", "(", "AVR_HAVE_RAMPZ", "&&", "(", "REG_Z", "==", "regno", "||", "REG_Z", "+", "1", "==", "regno", ")", "&&", "TEST_HARD_REG_BIT", "(", "*", "set", ",", "REG_Z", ")", "&&", "TEST_HARD_REG_BIT", "(", "*", "set", ",", "REG_Z", "+", "1", ")", ")", "continue", ";", "CLEAR_HARD_REG_BIT", "(", "*", "set", ",", "regno", ")", ";", "return", "regno", ";", "}", "return", "-", "1", ";", "}", "</s>" ]

[ "Unset", "a", "bit", "in", "*", "SET", ".", "If", "successful", ",", "return", "the", "respective", "bit", "number", ".", "Otherwise", ",", "return", "-1", "and", "*", "SET", "is", "unaltered", "." ]

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

[]

[ "<s>", "static", "recpe_type", "get_recpe_type", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_SFmode", ":", "return", "(", "gen_aarch64_frecpesf", ")", ";", "case", "E_V2SFmode", ":", "return", "(", "gen_aarch64_frecpev2sf", ")", ";", "case", "E_V4SFmode", ":", "return", "(", "gen_aarch64_frecpev4sf", ")", ";", "case", "E_DFmode", ":", "return", "(", "gen_aarch64_frecpedf", ")", ";", "case", "E_V2DFmode", ":", "return", "(", "gen_aarch64_frecpev2df", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Select", "reciprocal", "initial", "estimate", "insn", "depending", "on", "machine", "mode", "." ]

[ "aarch64" ]

[]

[ "<s>", "virtual", "bool", "addPassesToEmitMC", "(", "PassManagerBase", "&", ",", "MCContext", "*", "&", ",", "raw_ostream", "&", ",", "CodeGenOpt", "::", "Level", ",", "bool", "=", "true", ")", "{", "return", "true", ";", "}", "</s>" ]

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

[ "PTX" ]

[]

[ "<s>", "void", "bpf_expand_prologue", "(", "void", ")", "{", "HOST_WIDE_INT", "size", ";", "size", "=", "(", "cfun", "->", "machine", "->", "local_vars_size", "+", "cfun", "->", "machine", "->", "callee_saved_reg_size", ")", ";", "if", "(", "TARGET_XBPF", ")", "{", "int", "regno", ";", "int", "fp_offset", "=", "-", "cfun", "->", "machine", "->", "local_vars_size", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "{", "if", "(", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "||", "(", "cfun", "->", "calls_alloca", "&&", "regno", "==", "STACK_POINTER_REGNUM", ")", ")", "{", "rtx", "mem", ";", "if", "(", "!", "IN_RANGE", "(", "fp_offset", ",", "-", "1", "-", "0x7fff", ",", "0x7fff", ")", ")", "break", ";", "else", "{", "mem", "=", "gen_frame_mem", "(", "DImode", ",", "plus_constant", "(", "DImode", ",", "hard_frame_pointer_rtx", ",", "fp_offset", "-", "8", ")", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ")", ";", "fp_offset", "-=", "8", ";", "}", "}", "}", "}", "if", "(", "cfun", "->", "calls_alloca", ")", "{", "emit_move_insn", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ";", "if", "(", "size", ">", "0", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "size", ")", ")", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Expand", "to", "the", "instructions", "in", "a", "function", "prologue", ".", "This", "function", "is", "called", "when", "expanding", "the", "'prologue", "'", "pattern", "in", "bpf.md", "." ]

[ "bpf", "0", "1", "0x7fff", "0x7fff", "8", "8", "0" ]

[]

[ "<s>", "unsigned", "PIC16RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "FrameIndexValue", "*", "Value", ",", "RegScavenger", "*", "RS", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "0" ]

[]

[ "<s>", "bool", "mips_const_vector_same_bytes_p", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "int", "i", ",", "bytes", ";", "HOST_WIDE_INT", "val", ",", "first_byte", ";", "rtx", "first", ";", "if", "(", "!", "mips_const_vector_same_val_p", "(", "op", ",", "mode", ")", ")", "return", "false", ";", "first", "=", "CONST_VECTOR_ELT", "(", "op", ",", "0", ")", ";", "bytes", "=", "GET_MODE_UNIT_SIZE", "(", "mode", ")", ";", "val", "=", "INTVAL", "(", "first", ")", ";", "first_byte", "=", "val", "&", "0xff", ";", "for", "(", "i", "=", "1", ";", "i", "<", "bytes", ";", "i", "++", ")", "{", "val", ">>=", "8", ";", "if", "(", "(", "val", "&", "0xff", ")", "!=", "first_byte", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "constant", "vector", "with", "the", "number", "of", "units", "in", "MODE", ",", "and", "each", "unit", "has", "the", "same", "value", "as", "well", "as", "replicated", "bytes", "in", "the", "value", "." ]

[ "mips", "0", "0xff", "1", "8", "0xff" ]

[]

[ "<s>", "unsigned", "AAPMCCodeEmitter", "::", "getMachineOpValue", "(", "MCInst", "const", "&", "MI", ",", "MCOperand", "const", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "MCSubtargetInfo", "const", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "MCtx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "MCExpr", "::", "ExprKind", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "int64_t", "Res", ";", "if", "(", "Expr", "->", "evaluateAsAbsolute", "(", "Res", ")", ")", "return", "Res", ";", "assert", "(", "Kind", "==", "MCExpr", "::", "SymbolRef", "&&", "\"Currently only symbol operands are supported\"", ")", ";", "AAP", "::", "Fixups", "FixupKind", "=", "AAP", "::", "Fixups", "(", "0", ")", ";", "const", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "AAP", "::", "BAL", ")", "{", "FixupKind", "=", "AAP", "::", "fixup_AAP_BAL32", ";", "}", "else", "{", "assert", "(", "Opcode", "==", "AAP", "::", "BAL_short", "&&", "\"Unhandled MCInst for getMachineOpValue\"", ")", ";", "FixupKind", "=", "AAP", "::", "fixup_AAP_BAL16", ";", "}", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "FixupKind", ")", ",", "MI", ".", "getLoc", "(", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "AAP", "AAP", "\"Currently only symbol operands are supported\"", "AAP::Fixups", "AAP::Fixups", "0", "AAP::BAL", "AAP::fixup_AAP_BAL32", "AAP::BAL_short", "\"Unhandled MCInst for getMachineOpValue\"", "AAP::fixup_AAP_BAL16", "0", "0" ]

[]

[ "<s>", "static", "void", "ix86_emit_save_regs_using_mov", "(", "HOST_WIDE_INT", "cfa_offset", ")", "{", "unsigned", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "GENERAL_REGNO_P", "(", "regno", ")", "&&", "ix86_save_reg", "(", "regno", ",", "true", ")", ")", "{", "ix86_emit_save_reg_using_mov", "(", "word_mode", ",", "regno", ",", "cfa_offset", ")", ";", "cfa_offset", "-=", "UNITS_PER_WORD", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "save", "registers", "using", "MOV", "insns", ".", "First", "register", "is", "restored", "from", "POINTER", "+", "OFFSET", "." ]

[ "i386", "0" ]

[]

[ "<s>", "const", "char", "*", "AMDGPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "NODE_NAME_CASE", "(", "CALL", ")", ";", "NODE_NAME_CASE", "(", "UMUL", ")", ";", "NODE_NAME_CASE", "(", "DIV_INF", ")", ";", "NODE_NAME_CASE", "(", "RET_FLAG", ")", ";", "NODE_NAME_CASE", "(", "BRANCH_COND", ")", ";", "NODE_NAME_CASE", "(", "DWORDADDR", ")", "NODE_NAME_CASE", "(", "FRACT", ")", "NODE_NAME_CASE", "(", "FMAX", ")", "NODE_NAME_CASE", "(", "SMAX", ")", "NODE_NAME_CASE", "(", "UMAX", ")", "NODE_NAME_CASE", "(", "FMIN", ")", "NODE_NAME_CASE", "(", "SMIN", ")", "NODE_NAME_CASE", "(", "UMIN", ")", "NODE_NAME_CASE", "(", "URECIP", ")", "NODE_NAME_CASE", "(", "EXPORT", ")", "NODE_NAME_CASE", "(", "CONST_ADDRESS", ")", "NODE_NAME_CASE", "(", "REGISTER_LOAD", ")", "NODE_NAME_CASE", "(", "REGISTER_STORE", ")", "NODE_NAME_CASE", "(", "LOAD_CONSTANT", ")", "NODE_NAME_CASE", "(", "LOAD_INPUT", ")", "NODE_NAME_CASE", "(", "SAMPLE", ")", "NODE_NAME_CASE", "(", "SAMPLEB", ")", "NODE_NAME_CASE", "(", "SAMPLED", ")", "NODE_NAME_CASE", "(", "SAMPLEL", ")", "NODE_NAME_CASE", "(", "STORE_MSKOR", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT", ")", "}", "}", "</s>" ]

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

[ "R600", "0" ]

[]

[ "<s>", "static", "bool", "pdp11_handle_option", "(", "size_t", "code", ",", "const", "char", "*", "arg", "ATTRIBUTE_UNUSED", ",", "int", "value", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "code", ")", "{", "case", "OPT_m10", ":", "target_flags", "&=", "~", "(", "MASK_40", "|", "MASK_45", ")", ";", "return", "true", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_HANDLE_OPTION", "." ]

[ "pdp11" ]

[]

[ "<s>", "static", "bool", "arm_output_ttype", "(", "rtx", "x", ")", "{", "fputs", "(", "\"\\t.word\\t\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "CONST_INT", ")", "fputs", "(", "\"(TARGET2)\"", ",", "asm_out_file", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "return", "TRUE", ";", "}", "</s>" ]

[ "Output", "a", "reference", "from", "a", "function", "exception", "table", "to", "the", "type_info", "object", "X", ".", "The", "EABI", "specifies", "that", "the", "symbol", "should", "be", "relocated", "by", "an", "R_ARM_TARGET2", "relocation", "." ]

[ "arm", "\"\\t.word\\t\"", "\"(TARGET2)\"" ]

[]

[ "<s>", "bool", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "override", "{", "uint64_t", "NumNops", "=", "Count", "/", "4", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "NumNops", ";", "++", "i", ")", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "OS", ",", "0x60000000", ",", "Endian", ")", ";", "OS", ".", "write_zeros", "(", "Count", "%", "4", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "PowerPC", "4", "0", "support::endian", "0x60000000", "4" ]

[]

[ "<s>", "SDValue", "VideoCore4TargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "SDLoc", "&", "dl", "=", "CLI", ".", "DL", ";", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "isTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "isVarArg", "=", "CLI", ".", "IsVarArg", ";", "isTailCall", "=", "false", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "VideoCore4", "VideoCore4", "ISD::OutputArg", "ISD::InputArg", "\"Unsupported calling convention\"" ]

[]

[ "<s>", "static", "void", "update_total_code_bytes", "(", "unsigned", "int", "nbytes", ")", "{", "if", "(", "(", "TARGET_PORTABLE_RUNTIME", "||", "!", "TARGET_GAS", "||", "!", "TARGET_SOM", ")", "&&", "!", "IN_NAMED_SECTION_P", "(", "cfun", "->", "decl", ")", ")", "{", "unsigned", "int", "old_total", "=", "total_code_bytes", ";", "total_code_bytes", "+=", "nbytes", ";", "if", "(", "old_total", ">", "total_code_bytes", ")", "total_code_bytes", "=", "UINT_MAX", ";", "}", "}", "</s>" ]

[ "Update", "the", "total", "code", "bytes", "output", "to", "the", "text", "section", "." ]

[ "pa" ]

[]

[ "<s>", "unsigned", "NVPTXInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "0", ";", "--", "I", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "NVPTX", "::", "GOTO", "&&", "I", "->", "getOpcode", "(", ")", "!=", "NVPTX", "::", "CBranch", ")", "return", "0", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "1", ";", "--", "I", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "NVPTX", "::", "CBranch", ")", "return", "1", ";", "I", "->", "eraseFromParent", "(", ")", ";", "return", "2", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "\"code size not handled\"", "0", "NVPTX::GOTO", "NVPTX::CBranch", "0", "1", "NVPTX::CBranch", "1", "2" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "AdjustInstrPostInstrSelection", "(", "MachineInstr", "*", "MI", ",", "SDNode", "*", "Node", ")", "const", "{", "const", "MCInstrDesc", "*", "MCID", "=", "&", "MI", "->", "getDesc", "(", ")", ";", "unsigned", "NewOpc", "=", "convertAddSubFlagsOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "NewOpc", ")", "{", "const", "ARMBaseInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "getTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ")", ";", "MCID", "=", "&", "TII", "->", "get", "(", "NewOpc", ")", ";", "assert", "(", "MCID", "->", "getNumOperands", "(", ")", "==", "MI", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "+", "1", "&&", "\"converted opcode should be the same except for cc_out\"", ")", ";", "MI", "->", "setDesc", "(", "*", "MCID", ")", ";", "MI", "->", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "0", ",", "true", ")", ")", ";", "}", "unsigned", "ccOutIdx", "=", "MCID", "->", "getNumOperands", "(", ")", "-", "1", ";", "if", "(", "!", "MI", "->", "hasOptionalDef", "(", ")", "||", "!", "MCID", "->", "OpInfo", "[", "ccOutIdx", "]", ".", "isOptionalDef", "(", ")", ")", "{", "assert", "(", "!", "NewOpc", "&&", "\"Optional cc_out operand required\"", ")", ";", "return", ";", "}", "bool", "definesCPSR", "=", "false", ";", "bool", "deadCPSR", "=", "false", ";", "for", "(", "unsigned", "i", "=", "MCID", "->", "getNumOperands", "(", ")", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "ARM", "::", "CPSR", ")", "{", "definesCPSR", "=", "true", ";", "if", "(", "MO", ".", "isDead", "(", ")", ")", "deadCPSR", "=", "true", ";", "MI", "->", "RemoveOperand", "(", "i", ")", ";", "break", ";", "}", "}", "if", "(", "!", "definesCPSR", ")", "{", "assert", "(", "!", "NewOpc", "&&", "\"Optional cc_out operand required\"", ")", ";", "return", ";", "}", "assert", "(", "deadCPSR", "==", "!", "Node", "->", "hasAnyUseOfValue", "(", "1", ")", "&&", "\"inconsistent dead flag\"", ")", ";", "if", "(", "deadCPSR", ")", "{", "assert", "(", "!", "MI", "->", "getOperand", "(", "ccOutIdx", ")", ".", "getReg", "(", ")", "&&", "\"expect uninitialized optional cc_out operand\"", ")", ";", "return", ";", "}", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "ccOutIdx", ")", ";", "MO", ".", "setReg", "(", "ARM", "::", "CPSR", ")", ";", "MO", ".", "setIsDef", "(", "true", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "1", "\"converted opcode should be the same except for cc_out\"", "0", "1", "\"Optional cc_out operand required\"", "ARM::CPSR", "\"Optional cc_out operand required\"", "1", "\"inconsistent dead flag\"", "\"expect uninitialized optional cc_out operand\"", "ARM::CPSR" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "MSP430FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "MSP430InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MSP430InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "&", "Old", "=", "*", "I", ";", "uint64_t", "Amount", "=", "TII", ".", "getFrameSize", "(", "Old", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "alignTo", "(", "Amount", ",", "getStackAlign", "(", ")", ")", ";", "MachineInstr", "*", "New", "=", "nullptr", ";", "if", "(", "Old", ".", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "Old", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", ".", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "Amount", "-=", "TII", ".", "getFramePoppedByCallee", "(", "Old", ")", ";", "if", "(", "Amount", ")", "New", "=", "BuildMI", "(", "MF", ",", "Old", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "}", "else", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", "{", "if", "(", "uint64_t", "CalleeAmt", "=", "TII", ".", "getFramePoppedByCallee", "(", "*", "I", ")", ")", "{", "MachineInstr", "&", "Old", "=", "*", "I", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "Old", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "MSP430", "MSP430", "MSP430", "MSP430", "0", "MSP430::SUB16ri", "MSP430::SP", "MSP430::SP", "MSP430::ADD16ri", "MSP430::SP", "MSP430::SP", "3", "MSP430::SUB16ri", "MSP430::SP", "MSP430::SP", "3" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "void", "rs6000_d_target_versions", "(", "void", ")", "{", "if", "(", "TARGET_64BIT", ")", "d_add_builtin_version", "(", "\"PPC64\"", ")", ";", "else", "d_add_builtin_version", "(", "\"PPC\"", ")", ";", "if", "(", "TARGET_HARD_FLOAT", ")", "{", "d_add_builtin_version", "(", "\"PPC_HardFloat\"", ")", ";", "d_add_builtin_version", "(", "\"D_HardFloat\"", ")", ";", "}", "else", "if", "(", "TARGET_SOFT_FLOAT", ")", "{", "d_add_builtin_version", "(", "\"PPC_SoftFloat\"", ")", ";", "d_add_builtin_version", "(", "\"D_SoftFloat\"", ")", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_D_CPU_VERSIONS", "for", "PowerPC", "targets", "." ]

[ "rs6000", "\"PPC64\"", "\"PPC\"", "\"PPC_HardFloat\"", "\"D_HardFloat\"", "\"PPC_SoftFloat\"", "\"D_SoftFloat\"" ]

[]

[ "<s>", "std", "::", "unique_ptr", "<", "TargetInstrInfo", "::", "PipelinerLoopInfo", ">", "HexagonInstrInfo", "::", "analyzeLoopForPipelining", "(", "MachineBasicBlock", "*", "LoopBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "LoopBB", "->", "getFirstTerminator", "(", ")", ";", "if", "(", "I", "!=", "LoopBB", "->", "end", "(", ")", "&&", "isEndLoopN", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "8", ">", "VisitedBBs", ";", "MachineInstr", "*", "LoopInst", "=", "findLoopInstr", "(", "LoopBB", ",", "I", "->", "getOpcode", "(", ")", ",", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ",", "VisitedBBs", ")", ";", "if", "(", "LoopInst", ")", "return", "std", "::", "make_unique", "<", "HexagonPipelinerLoopInfo", ">", "(", "LoopInst", ",", "&", "*", "I", ")", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "Analyze", "loop", "L", ",", "which", "must", "be", "a", "single-basic-block", "loop", ",", "and", "if", "the", "conditions", "can", "be", "understood", "enough", "produce", "a", "PipelinerLoopInfo", "object", "." ]

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

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "getNumWaitStates", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "1", ";", "case", "AMDGPU", "::", "S_NOP", ":", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "+", "1", ";", "}", "}", "</s>" ]

[ "Return", "the", "number", "of", "wait", "states", "that", "result", "from", "executing", "this", "instruction", "." ]

[ "AMDGPU", "SI", "1", "AMDGPU::S_NOP", "0", "1" ]

[]

[ "<s>", "static", "void", "microblaze_adjust_block_mem", "(", "rtx", "mem", ",", "HOST_WIDE_INT", "length", ",", "rtx", "*", "loop_reg", ",", "rtx", "*", "loop_mem", ")", "{", "*", "loop_reg", "=", "copy_addr_to_reg", "(", "XEXP", "(", "mem", ",", "0", ")", ")", ";", "*", "loop_mem", "=", "change_address", "(", "mem", ",", "BLKmode", ",", "*", "loop_reg", ")", ";", "set_mem_align", "(", "*", "loop_mem", ",", "MIN", "(", "(", "HOST_WIDE_INT", ")", "MEM_ALIGN", "(", "mem", ")", ",", "length", "*", "BITS_PER_UNIT", ")", ")", ";", "}", "</s>" ]

[ "Helper", "function", "for", "doing", "a", "loop-based", "block", "operation", "on", "memory", "reference", "MEM", ".", "Each", "iteration", "of", "the", "loop", "will", "operate", "on", "LENGTH", "bytes", "of", "MEM", ".", "Create", "a", "new", "base", "register", "for", "use", "within", "the", "loop", "and", "point", "it", "to", "the", "start", "of", "MEM", ".", "Create", "a", "new", "memory", "reference", "that", "uses", "this", "register", ".", "Store", "them", "in", "*", "LOOP_REG", "and", "*", "LOOP_MEM", "respectively", "." ]

[ "microblaze", "0" ]

[]

[ "<s>", "bool", "HexagonFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "bool", "ContiguousRegs", "=", "true", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "unsigned", "SuperReg", "=", "uniqueSuperReg", "(", "Reg", ",", "TRI", ")", ";", "const", "TargetRegisterClass", "*", "SuperRegClass", "=", "nullptr", ";", "bool", "CanUseDblLoad", "=", "false", ";", "if", "(", "ContiguousRegs", "&&", "(", "i", "<", "CSI", ".", "size", "(", ")", "-", "1", ")", ")", "{", "unsigned", "SuperRegNext", "=", "uniqueSuperReg", "(", "CSI", "[", "i", "+", "1", "]", ".", "getReg", "(", ")", ",", "TRI", ")", ";", "SuperRegClass", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "SuperReg", ")", ";", "CanUseDblLoad", "=", "(", "SuperRegNext", "==", "SuperReg", ")", ";", "}", "if", "(", "CanUseDblLoad", ")", "{", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "SuperReg", ",", "CSI", "[", "i", "+", "1", "]", ".", "getFrameIdx", "(", ")", ",", "SuperRegClass", ",", "TRI", ")", ";", "MBB", ".", "addLiveIn", "(", "SuperReg", ")", ";", "++", "i", ";", "}", "else", "{", "ContiguousRegs", "=", "false", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "X86WinCOFFStreamer", "::", "finishImpl", "(", ")", "{", "emitFrames", "(", "nullptr", ")", ";", "emitWindowsUnwindTables", "(", ")", ";", "MCWinCOFFStreamer", "::", "finishImpl", "(", ")", ";", "}", "</s>" ]

[ "Streamer", "specific", "finalization", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"ARM64 pseudo instruction expansion pass\"", ";", "}", "</s>" ]

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

[ "ARM64", "\"ARM64 pseudo instruction expansion pass\"" ]

[]

[ "<s>", "static", "rtx", "pro_epilogue_adjust_stack", "(", "rtx", "dest", ",", "rtx", "src", ",", "rtx", "offset", ",", "int", "style", ",", "bool", "set_cfa", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "rtx", "addend", "=", "offset", ";", "rtx", "insn", ";", "bool", "add_frame_related_expr", "=", "false", ";", "if", "(", "!", "x86_64_immediate_operand", "(", "offset", ",", "Pmode", ")", ")", "{", "if", "(", "style", ")", "addend", "=", "gen_rtx_REG", "(", "Pmode", ",", "R11_REG", ")", ";", "else", "{", "gcc_assert", "(", "src", "!=", "hard_frame_pointer_rtx", "&&", "dest", "!=", "hard_frame_pointer_rtx", ")", ";", "addend", "=", "hard_frame_pointer_rtx", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "addend", ",", "offset", ")", ")", ";", "if", "(", "style", "<", "0", ")", "add_frame_related_expr", "=", "true", ";", "}", "insn", "=", "emit_insn", "(", "gen_pro_epilogue_adjust_stack_add", "(", "Pmode", ",", "dest", ",", "src", ",", "addend", ")", ")", ";", "if", "(", "style", ">=", "0", ")", "ix86_add_queued_cfa_restore_notes", "(", "insn", ")", ";", "if", "(", "set_cfa", ")", "{", "rtx", "r", ";", "gcc_assert", "(", "m", "->", "fs", ".", "cfa_reg", "==", "src", ")", ";", "m", "->", "fs", ".", "cfa_offset", "+=", "INTVAL", "(", "offset", ")", ";", "m", "->", "fs", ".", "cfa_reg", "=", "dest", ";", "r", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "src", ",", "offset", ")", ";", "r", "=", "gen_rtx_SET", "(", "dest", ",", "r", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "r", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "else", "if", "(", "style", "<", "0", ")", "{", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "if", "(", "add_frame_related_expr", ")", "{", "rtx", "r", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "src", ",", "offset", ")", ";", "r", "=", "gen_rtx_SET", "(", "dest", ",", "r", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "r", ")", ";", "}", "}", "if", "(", "dest", "==", "stack_pointer_rtx", ")", "{", "HOST_WIDE_INT", "ooffset", "=", "m", "->", "fs", ".", "sp_offset", ";", "bool", "valid", "=", "m", "->", "fs", ".", "sp_valid", ";", "bool", "realigned", "=", "m", "->", "fs", ".", "sp_realigned", ";", "if", "(", "src", "==", "hard_frame_pointer_rtx", ")", "{", "valid", "=", "m", "->", "fs", ".", "fp_valid", ";", "realigned", "=", "false", ";", "ooffset", "=", "m", "->", "fs", ".", "fp_offset", ";", "}", "else", "if", "(", "src", "==", "crtl", "->", "drap_reg", ")", "{", "valid", "=", "m", "->", "fs", ".", "drap_valid", ";", "realigned", "=", "false", ";", "ooffset", "=", "0", ";", "}", "else", "{", "gcc_checking_assert", "(", "src", "==", "stack_pointer_rtx", "||", "offset", "==", "const0_rtx", ")", ";", "}", "m", "->", "fs", ".", "sp_offset", "=", "ooffset", "-", "INTVAL", "(", "offset", ")", ";", "m", "->", "fs", ".", "sp_valid", "=", "valid", ";", "m", "->", "fs", ".", "sp_realigned", "=", "realigned", ";", "}", "return", "insn", ";", "}", "</s>" ]

[ "Expand", "prologue", "or", "epilogue", "stack", "adjustment", ".", "The", "pattern", "exist", "to", "put", "a", "dependency", "on", "all", "ebp-based", "memory", "accesses", ".", "STYLE", "should", "be", "negative", "if", "instructions", "should", "be", "marked", "as", "frame", "related", ",", "zero", "if", "%", "r11", "register", "is", "live", "and", "can", "not", "be", "freely", "used", "and", "positive", "otherwise", "." ]

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

[]

[ "<s>", "bool", "RISCVCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "ArrayRef", "<", "Register", ">>", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "bool", "CFGStructurizer", "<", "PassT", ">", "::", "prepare", "(", "FuncT", "&", "func", ",", "PassT", "&", "pass", ",", "const", "AMDGPURegisterInfo", "*", "tri", ")", "{", "passRep", "=", "&", "pass", ";", "funcRep", "=", "&", "func", ";", "TRI", "=", "tri", ";", "bool", "changed", "=", "false", ";", "if", "(", "DEBUGME", ")", "{", "errs", "(", ")", "<<", "\"AMDGPUCFGStructurizer::prepare\\n\"", ";", "}", "loopInfo", "=", "CFGTraits", "::", "getLoopInfo", "(", "pass", ")", ";", "if", "(", "DEBUGME", ")", "{", "errs", "(", ")", "<<", "\"LoopInfo:\\n\"", ";", "PrintLoopinfo", "(", "*", "loopInfo", ",", "errs", "(", ")", ")", ";", "}", "orderBlocks", "(", ")", ";", "if", "(", "DEBUGME", ")", "{", "errs", "(", ")", "<<", "\"Ordered blocks:\\n\"", ";", "printOrderedBlocks", "(", "errs", "(", ")", ")", ";", "}", "SmallVector", "<", "BlockT", "*", ",", "DEFAULT_VEC_SLOTS", ">", "retBlks", ";", "for", "(", "typename", "LoopInfoT", "::", "iterator", "iter", "=", "loopInfo", "->", "begin", "(", ")", ",", "iterEnd", "=", "loopInfo", "->", "end", "(", ")", ";", "iter", "!=", "iterEnd", ";", "++", "iter", ")", "{", "LoopT", "*", "loopRep", "=", "(", "*", "iter", ")", ";", "BlockTSmallerVector", "exitingBlks", ";", "loopRep", "->", "getExitingBlocks", "(", "exitingBlks", ")", ";", "if", "(", "exitingBlks", ".", "size", "(", ")", "==", "0", ")", "{", "BlockT", "*", "dummyExitBlk", "=", "normalizeInfiniteLoopExit", "(", "loopRep", ")", ";", "if", "(", "dummyExitBlk", "!=", "NULL", ")", "retBlks", ".", "push_back", "(", "dummyExitBlk", ")", ";", "}", "}", "for", "(", "typename", "SmallVector", "<", "BlockT", "*", ",", "DEFAULT_VEC_SLOTS", ">", "::", "const_iterator", "iterBlk", "=", "orderedBlks", ".", "begin", "(", ")", ",", "iterEndBlk", "=", "orderedBlks", ".", "end", "(", ")", ";", "iterBlk", "!=", "iterEndBlk", ";", "++", "iterBlk", ")", "{", "BlockT", "*", "curBlk", "=", "*", "iterBlk", ";", "removeUnconditionalBranch", "(", "curBlk", ")", ";", "removeRedundantConditionalBranch", "(", "curBlk", ")", ";", "if", "(", "CFGTraits", "::", "isReturnBlock", "(", "curBlk", ")", ")", "{", "retBlks", ".", "push_back", "(", "curBlk", ")", ";", "}", "assert", "(", "curBlk", "->", "succ_size", "(", ")", "<=", "2", ")", ";", "}", "if", "(", "retBlks", ".", "size", "(", ")", ">=", "2", ")", "{", "addDummyExitBlock", "(", "retBlks", ")", ";", "changed", "=", "true", ";", "}", "return", "changed", ";", "}", "</s>" ]

[ "prepare", "-", "Reset", "state", "and", "prepare", "for", "a", "new", "spill", "placement", "computation", "." ]

[ "R600", "\"AMDGPUCFGStructurizer::prepare\\n\"", "\"LoopInfo:\\n\"", "\"Ordered blocks:\\n\"", "0", "2", "2" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Mips", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "MipsFI", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "\"sret virtual register not created in the entry block\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "getPointerTy", "(", ")", ")", ";", "unsigned", "V0", "=", "IsN64", "?", "Mips", "::", "V0_64", ":", "Mips", "::", "V0", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "V0", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "V0", ",", "getPointerTy", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "MipsISD", "::", "Ret", ",", "dl", ",", "MVT", "::", "Other", ",", "&", "RetOps", "[", "0", "]", ",", "RetOps", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::OutputArg", "16", "Mips", "4", "1", "0", "\"Can only return in registers!\"", "1", "Mips", "Mips", "Mips", "Mips", "\"sret virtual register not created in the entry block\"", "Mips::V0_64", "Mips::V0", "1", "0", "MipsISD::Ret", "MVT::Other", "0" ]

[]

[ "<s>", "void", "rs6000_emit_le_vsx_load", "(", "rtx", "dest", ",", "rtx", "source", ",", "machine_mode", "mode", ")", "{", "rtx", "tmp", ",", "permute_mem", ",", "permute_reg", ";", "if", "(", "mode", "==", "TImode", "||", "mode", "==", "V1TImode", ")", "{", "mode", "=", "V2DImode", ";", "dest", "=", "gen_lowpart", "(", "V2DImode", ",", "dest", ")", ";", "source", "=", "adjust_address", "(", "source", ",", "V2DImode", ",", "0", ")", ";", "}", "tmp", "=", "can_create_pseudo_p", "(", ")", "?", "gen_reg_rtx_and_attrs", "(", "dest", ")", ":", "dest", ";", "permute_mem", "=", "rs6000_gen_le_vsx_permute", "(", "source", ",", "mode", ")", ";", "permute_reg", "=", "rs6000_gen_le_vsx_permute", "(", "tmp", ",", "mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp", ",", "permute_mem", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "permute_reg", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "little-endian", "load", "from", "vector", "memory", "location", "SOURCE", "to", "VSX", "register", "DEST", "in", "mode", "MODE", ".", "The", "load", "is", "done", "with", "two", "permuting", "insn", "'s", "that", "represent", "an", "lxvd2x", "and", "xxpermdi", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected Kind in getPointerRegClass!\"", ")", ";", "case", "0", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", ")", "return", "&", "X86", "::", "GR64RegClass", ";", "return", "&", "X86", "::", "GR32RegClass", ";", "case", "1", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOSPRegClass", ";", "return", "&", "X86", "::", "GR32_NOSPRegClass", ";", "case", "2", ":", "if", "(", "Subtarget", ".", "isTargetWin64", "(", ")", ")", "return", "&", "X86", "::", "GR64_TCW64RegClass", ";", "else", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "return", "&", "X86", "::", "GR64_TCRegClass", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "hasHipeCC", "=", "(", "F", "?", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "HiPE", ":", "false", ")", ";", "if", "(", "hasHipeCC", ")", "return", "&", "X86", "::", "GR32RegClass", ";", "return", "&", "X86", "::", "GR32_TCRegClass", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"Unexpected Kind in getPointerRegClass!\"", "0", "X86::GR64RegClass", "X86::GR32RegClass", "1", "X86::GR64_NOSPRegClass", "X86::GR32_NOSPRegClass", "2", "X86::GR64_TCW64RegClass", "X86::GR64_TCRegClass", "X86::GR32RegClass", "X86::GR32_TCRegClass" ]

[]

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

[ "Enable", "use", "of", "alias", "analysis", "during", "code", "generation", "(", "during", "MI", "scheduling", ",", "DAGCombine", ",", "etc", ".", ")", "." ]

[ "SystemZ" ]

[]

[ "<s>", "bool", "ARMTTIImpl", "::", "isLegalMaskedGather", "(", "Type", "*", "Ty", ",", "MaybeAlign", "Alignment", ")", "{", "if", "(", "!", "EnableMaskedGatherScatters", "||", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "if", "(", "isa", "<", "VectorType", ">", "(", "Ty", ")", ")", "return", "false", ";", "unsigned", "EltWidth", "=", "Ty", "->", "getScalarSizeInBits", "(", ")", ";", "return", "(", "(", "EltWidth", "==", "32", "&&", "(", "!", "Alignment", "||", "Alignment", ">=", "4", ")", ")", "||", "(", "EltWidth", "==", "16", "&&", "(", "!", "Alignment", "||", "Alignment", ">=", "2", ")", ")", "||", "EltWidth", "==", "8", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "32", "4", "16", "2", "8" ]

[]

[ "<s>", "static", "void", "output_file_start", "(", "void", ")", "{", "FILE", "*", "file", "=", "asm_out_file", ";", "int", "i", ";", "fprintf", "(", "file", ",", "\".file \\\"%s\\\";\\n\"", ",", "LOCATION_FILE", "(", "input_location", ")", ")", ";", "for", "(", "i", "=", "0", ";", "arg_regs", "[", "i", "]", ">=", "0", ";", "i", "++", ")", ";", "max_arg_registers", "=", "i", ";", "}", "</s>" ]

[ "Output", "to", "FILE", "the", "start", "of", "the", "assembler", "file", "." ]

[ "bfin", "\".file \\\"%s\\\";\\n\"", "0", "0" ]

[]

[ "<s>", "unsigned", "TOYMCCodeEmitter", "::", "getBranchTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "llvm_unreachable", "(", "\"getBranchTargetOpValue is not implemented yet\"", ")", ";", "}", "</s>" ]

[ "getBranchTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

[ "TOY", "TOY", "\"getBranchTargetOpValue is not implemented yet\"" ]

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "SetupMachineFunction", "(", "MF", ")", ";", "if", "(", "Subtarget", "->", "isTargetCOFF", "(", ")", "&&", "!", "Subtarget", "->", "isTargetEnvMacho", "(", ")", ")", "{", "bool", "Intrn", "=", "MF", ".", "getFunction", "(", ")", "->", "hasInternalLinkage", "(", ")", ";", "OutStreamer", ".", "BeginCOFFSymbolDef", "(", "CurrentFnSym", ")", ";", "OutStreamer", ".", "EmitCOFFSymbolStorageClass", "(", "Intrn", "?", "COFF", "::", "IMAGE_SYM_CLASS_STATIC", ":", "COFF", "::", "IMAGE_SYM_CLASS_EXTERNAL", ")", ";", "OutStreamer", ".", "EmitCOFFSymbolType", "(", "COFF", "::", "IMAGE_SYM_DTYPE_FUNCTION", "<<", "COFF", "::", "SCT_COMPLEX_TYPE_SHIFT", ")", ";", "OutStreamer", ".", "EndCOFFSymbolDef", "(", ")", ";", "}", "EmitFunctionHeader", "(", ")", ";", "EmitFunctionBody", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

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

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "XCore", "MVT::i32" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "static", "void", "riscv_for_each_saved_reg", "(", "HOST_WIDE_INT", "sp_offset", ",", "riscv_save_restore_fn", "fn", ")", "{", "HOST_WIDE_INT", "offset", ";", "offset", "=", "cfun", "->", "machine", "->", "frame", ".", "gp_sp_offset", "-", "sp_offset", ";", "for", "(", "int", "regno", "=", "GP_REG_FIRST", ";", "regno", "<=", "GP_REG_LAST", "-", "1", ";", "regno", "++", ")", "if", "(", "BITSET_P", "(", "cfun", "->", "machine", "->", "frame", ".", "mask", ",", "regno", "-", "GP_REG_FIRST", ")", ")", "{", "riscv_save_restore_reg", "(", "word_mode", ",", "regno", ",", "offset", ",", "fn", ")", ";", "offset", "-=", "UNITS_PER_WORD", ";", "}", "offset", "=", "cfun", "->", "machine", "->", "frame", ".", "fp_sp_offset", "-", "sp_offset", ";", "for", "(", "int", "regno", "=", "FP_REG_FIRST", ";", "regno", "<=", "FP_REG_LAST", ";", "regno", "++", ")", "if", "(", "BITSET_P", "(", "cfun", "->", "machine", "->", "frame", ".", "fmask", ",", "regno", "-", "FP_REG_FIRST", ")", ")", "{", "enum", "machine_mode", "mode", "=", "TARGET_DOUBLE_FLOAT", "?", "DFmode", ":", "SFmode", ";", "riscv_save_restore_reg", "(", "mode", ",", "regno", ",", "offset", ",", "fn", ")", ";", "offset", "-=", "GET_MODE_SIZE", "(", "mode", ")", ";", "}", "}", "</s>" ]

[ "Call", "FN", "for", "each", "register", "that", "is", "saved", "by", "the", "current", "function", ".", "SP_OFFSET", "is", "the", "offset", "of", "the", "current", "stack", "pointer", "from", "the", "start", "of", "the", "frame", "." ]

[ "riscv", "1" ]

[]

[ "<s>", "static", "bool", "mips_strict_matching_cpu_name_p", "(", "const", "char", "*", "canonical", ",", "const", "char", "*", "given", ")", "{", "while", "(", "*", "given", "!=", "0", "&&", "TOLOWER", "(", "*", "given", ")", "==", "TOLOWER", "(", "*", "canonical", ")", ")", "given", "++", ",", "canonical", "++", ";", "return", "(", "(", "*", "given", "==", "0", "&&", "*", "canonical", "==", "0", ")", "||", "(", "strcmp", "(", "canonical", ",", "\"000\"", ")", "==", "0", "&&", "strcasecmp", "(", "given", ",", "\"k\"", ")", "==", "0", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "GIVEN", "is", "the", "same", "as", "CANONICAL", ",", "or", "if", "it", "is", "CANONICAL", "with", "a", "final", "``", "000", "''", "replaced", "by", "``", "k", "''", ".", "Ignore", "case", ".", "Note", ":", "this", "function", "is", "shared", "between", "GCC", "and", "GAS", "." ]

[ "mips", "0", "0", "0", "\"000\"", "0", "\"k\"", "0" ]

[]

[ "<s>", "rtx", "aarch64_return_addr", "(", "int", "count", ",", "rtx", "frame", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "count", "!=", "0", ")", "return", "const0_rtx", ";", "return", "get_hard_reg_initial_val", "(", "Pmode", ",", "LR_REGNUM", ")", ";", "}", "</s>" ]

[ "Implement", "RETURN_ADDR_RTX", ".", "We", "do", "not", "support", "moving", "back", "to", "a", "previous", "frame", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addPreISel", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "addPass", "(", "createFlattenCFGPass", "(", ")", ")", ";", "if", "(", "ST", ".", "IsIRStructurizerEnabled", "(", ")", ")", "addPass", "(", "createStructurizeCFGPass", "(", ")", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "addPass", "(", "createSinkingPass", "(", ")", ")", ";", "addPass", "(", "createSITypeRewriter", "(", ")", ")", ";", "addPass", "(", "createSIAnnotateControlFlowPass", "(", ")", ")", ";", "}", "else", "{", "addPass", "(", "createR600TextureIntrinsicsReplacer", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

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

[]

[ "<s>", "void", "AArch64TargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "APInt", "&", "KnownZero", ",", "APInt", "&", "KnownOne", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64ISD", "::", "CSEL", ":", "{", "APInt", "KnownZero2", ",", "KnownOne2", ";", "DAG", ".", "computeKnownBits", "(", "Op", "->", "getOperand", "(", "0", ")", ",", "KnownZero", ",", "KnownOne", ",", "Depth", "+", "1", ")", ";", "DAG", ".", "computeKnownBits", "(", "Op", "->", "getOperand", "(", "1", ")", ",", "KnownZero2", ",", "KnownOne2", ",", "Depth", "+", "1", ")", ";", "KnownZero", "&=", "KnownZero2", ";", "KnownOne", "&=", "KnownOne2", ";", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "ConstantSDNode", "*", "CN", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "1", ")", ")", ";", "Intrinsic", "::", "ID", "IntID", "=", "static_cast", "<", "Intrinsic", "::", "ID", ">", "(", "CN", "->", "getZExtValue", "(", ")", ")", ";", "switch", "(", "IntID", ")", "{", "default", ":", "return", ";", "case", "Intrinsic", "::", "aarch64_ldaxr", ":", "case", "Intrinsic", "::", "aarch64_ldxr", ":", "{", "unsigned", "BitWidth", "=", "KnownOne", ".", "getBitWidth", "(", ")", ";", "EVT", "VT", "=", "cast", "<", "MemIntrinsicSDNode", ">", "(", "Op", ")", "->", "getMemoryVT", "(", ")", ";", "unsigned", "MemBits", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "KnownZero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "MemBits", ")", ";", "return", ";", "}", "}", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "case", "ISD", "::", "INTRINSIC_VOID", ":", "{", "unsigned", "IntNo", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ";", "switch", "(", "IntNo", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "aarch64_neon_umaxv", ":", "case", "Intrinsic", "::", "aarch64_neon_uminv", ":", "{", "MVT", "VT", "=", "Op", ".", "getOperand", "(", "1", ")", ".", "getValueType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "unsigned", "BitWidth", "=", "KnownZero", ".", "getBitWidth", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "v8i8", "||", "VT", "==", "MVT", "::", "v16i8", ")", "{", "assert", "(", "BitWidth", ">=", "8", "&&", "\"Unexpected width!\"", ")", ";", "APInt", "Mask", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "8", ")", ";", "KnownZero", "|=", "Mask", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "v4i16", "||", "VT", "==", "MVT", "::", "v8i16", ")", "{", "assert", "(", "BitWidth", ">=", "16", "&&", "\"Unexpected width!\"", ")", ";", "APInt", "Mask", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "16", ")", ";", "KnownZero", "|=", "Mask", ";", "}", "break", ";", "}", "break", ";", "}", "}", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64ISD::CSEL", "0", "1", "1", "1", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::ID", "Intrinsic::ID", "Intrinsic::aarch64_ldaxr", "Intrinsic::aarch64_ldxr", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_VOID", "0", "Intrinsic::aarch64_neon_umaxv", "Intrinsic::aarch64_neon_uminv", "1", "MVT::v8i8", "MVT::v16i8", "8", "\"Unexpected width!\"", "8", "MVT::v4i16", "MVT::v8i16", "16", "\"Unexpected width!\"", "16" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "MipsRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "MipsABIInfo", "ABI", "=", "MF", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "getABI", "(", ")", ";", "MipsPtrClass", "PtrClassKind", "=", "static_cast", "<", "MipsPtrClass", ">", "(", "Kind", ")", ";", "switch", "(", "PtrClassKind", ")", "{", "case", "MipsPtrClass", "::", "Default", ":", "return", "ABI", ".", "ArePtrs64bit", "(", ")", "?", "&", "Mips", "::", "GPR64RegClass", ":", "&", "Mips", "::", "GPR32RegClass", ";", "case", "MipsPtrClass", "::", "GPR16MM", ":", "return", "&", "Mips", "::", "GPRMM16RegClass", ";", "case", "MipsPtrClass", "::", "StackPointer", ":", "return", "ABI", ".", "ArePtrs64bit", "(", ")", "?", "&", "Mips", "::", "SP64RegClass", ":", "&", "Mips", "::", "SP32RegClass", ";", "case", "MipsPtrClass", "::", "GlobalPointer", ":", "return", "ABI", ".", "ArePtrs64bit", "(", ")", "?", "&", "Mips", "::", "GP64RegClass", ":", "&", "Mips", "::", "GP32RegClass", ";", "}", "llvm_unreachable", "(", "\"Unknown pointer kind\"", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "MipsPtrClass::Default", "Mips::GPR64RegClass", "Mips::GPR32RegClass", "MipsPtrClass::GPR16MM", "Mips::GPRMM16RegClass", "MipsPtrClass::StackPointer", "Mips::SP64RegClass", "Mips::SP32RegClass", "MipsPtrClass::GlobalPointer", "Mips::GP64RegClass", "Mips::GP32RegClass", "\"Unknown pointer kind\"" ]

[]

[ "<s>", "Optional", "<", "DestSourcePair", ">", "RISCVInstrInfo", "::", "isCopyInstrImpl", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "isMoveReg", "(", ")", ")", "return", "DestSourcePair", "{", "MI", ".", "getOperand", "(", "0", ")", ",", "MI", ".", "getOperand", "(", "1", ")", "}", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "RISCV", "::", "ADDI", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "return", "DestSourcePair", "{", "MI", ".", "getOperand", "(", "0", ")", ",", "MI", ".", "getOperand", "(", "1", ")", "}", ";", "break", ";", "case", "RISCV", "::", "FSGNJ_D", ":", "case", "RISCV", "::", "FSGNJ_S", ":", "case", "RISCV", "::", "FSGNJ_H", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", "return", "DestSourcePair", "{", "MI", ".", "getOperand", "(", "0", ")", ",", "MI", ".", "getOperand", "(", "1", ")", "}", ";", "break", ";", "}", "return", "None", ";", "}", "</s>" ]

[ "If", "the", "specific", "machine", "instruction", "is", "a", "instruction", "that", "moves/copies", "value", "from", "one", "register", "to", "another", "register", "return", "destination", "and", "source", "registers", "as", "machine", "operands", "." ]

[ "RISCV", "RISCV", "0", "1", "RISCV::ADDI", "1", "2", "2", "0", "0", "1", "RISCV::FSGNJ_D", "RISCV::FSGNJ_S", "RISCV::FSGNJ_H", "1", "2", "1", "2", "0", "1" ]

[]

[ "<s>", "bool", "MBlazePassConfig", "::", "addInstSelector", "(", ")", "{", "PM", ".", "add", "(", "createMBlazeISelDag", "(", "getMBlazeTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze", "MBlaze" ]

[]

[ "<s>", "BitVector", "PPCRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "const", "PPCFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "ZERO", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "FP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "BP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "CTR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "CTR8", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R1", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "LR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "LR8", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "RM", ")", ";", "if", "(", "!", "Subtarget", ".", "isDarwinABI", "(", ")", "||", "!", "Subtarget", ".", "hasAltivec", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "VRSAVE", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "const", "PPCFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "TM", ".", "isPPC64", "(", ")", "||", "FuncInfo", "->", "usesTOCBasePtr", "(", ")", "||", "MF", ".", "hasInlineAsm", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R2", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R13", ")", ";", "}", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R2", ")", ";", "if", "(", "TM", ".", "isPPC64", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R13", ")", ";", "if", "(", "TFI", "->", "needsFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R31", ")", ";", "bool", "IsPositionIndependent", "=", "TM", ".", "isPositionIndependent", "(", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "{", "if", "(", "Subtarget", ".", "is32BitELFABI", "(", ")", "&&", "IsPositionIndependent", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R29", ")", ";", "else", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R30", ")", ";", "}", "if", "(", "Subtarget", ".", "is32BitELFABI", "(", ")", "&&", "IsPositionIndependent", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R30", ")", ";", "if", "(", "!", "Subtarget", ".", "hasAltivec", "(", ")", ")", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "PPC", "::", "VRRCRegClass", ".", "begin", "(", ")", ",", "IE", "=", "PPC", "::", "VRRCRegClass", ".", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "markSuperRegs", "(", "Reserved", ",", "*", "I", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC::ZERO", "PPC::FP", "PPC::BP", "PPC::CTR", "PPC::CTR8", "PPC::R1", "PPC::LR", "PPC::LR8", "PPC::RM", "PPC::VRSAVE", "PPC", "PPC", "PPC", "PPC::R2", "PPC::R13", "PPC::R2", "PPC", "PPC::R13", "PPC::R31", "PPC::R29", "PPC::R30", "PPC::R30", "PPC::VRRCRegClass", "PPC::VRRCRegClass" ]

[]

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

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

[ "DLX", "DLX" ]

[]

[ "<s>", "bool", "MBlazeTargetObjectFile", "::", "IsGlobalInSmallSection", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ",", "SectionKind", "Kind", ")", "const", "{", "const", "GlobalVariable", "*", "GVA", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GV", ")", ";", "if", "(", "!", "GVA", ")", "return", "false", ";", "if", "(", "!", "Kind", ".", "isBSS", "(", ")", "&&", "!", "Kind", ".", "isDataRel", "(", ")", ")", "return", "false", ";", "if", "(", "Kind", ".", "isMergeable1ByteCString", "(", ")", ")", "return", "false", ";", "Type", "*", "Ty", "=", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ";", "return", "IsInSmallSection", "(", "TM", ".", "getTargetData", "(", ")", "->", "getTypeAllocSize", "(", "Ty", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "global", "address", "should", "be", "placed", "into", "small", "data/bss", "section", "." ]

[ "MBlaze", "MBlaze" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "unsigned", "FPReg", "=", "getFPReg", "(", "STI", ")", ";", "unsigned", "SPReg", "=", "getSPReg", "(", "STI", ")", ";", "DebugLoc", "DL", ";", "if", "(", "shouldEnableVectorUnit", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "STI", ".", "getInstrInfo", "(", ")", "->", "get", "(", "RISCV", "::", "VCONFIG", ")", ")", ".", "addImm", "(", "0x60", ")", ";", "}", "determineFrameLayout", "(", "MF", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", ".", "adjustsStack", "(", ")", ")", "return", ";", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "-", "StackSize", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "std", "::", "advance", "(", "MBBI", ",", "CSI", ".", "size", "(", ")", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "FPReg", ",", "SPReg", ",", "StackSize", "-", "RVFI", "->", "getVarArgsSaveSize", "(", ")", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"Shrink-wrapping not yet supported\"", "RISCV", "RISCV::VCONFIG", "0x60", "0" ]

[]

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

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

[ "X86", "X86" ]

[]

[ "<s>", "unsigned", "SPIRVTargetLowering", "::", "getNumRegistersForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "isVector", "(", ")", "&&", "VT", ".", "getVectorNumElements", "(", ")", "==", "3", "&&", "(", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", "||", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i8", ")", ")", "return", "1", ";", "return", "getNumRegisters", "(", "Context", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "SPIRV", "SPIRV", "3", "MVT::i1", "MVT::i8", "1" ]

[]

[ "<s>", "static", "inline", "int", "shiftcosts", "(", "rtx", "x", ")", "{", "int", "value", ";", "if", "(", "TARGET_SHMEDIA", ")", "return", "1", ";", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ">", "UNITS_PER_WORD", ")", "{", "if", "(", "GET_MODE", "(", "x", ")", "==", "DImode", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "1", ")", "return", "2", ";", "return", "10000", ";", "}", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "SH_DYNAMIC_SHIFT_COST", ";", "value", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "ASHIFTRT", ")", "{", "int", "cost", "=", "ashiftrt_insns", "[", "value", "]", ";", "if", "(", "cost", ">", "1", "+", "SH_DYNAMIC_SHIFT_COST", ")", "cost", "=", "1", "+", "SH_DYNAMIC_SHIFT_COST", ";", "return", "cost", ";", "}", "else", "return", "shift_insns", "[", "value", "]", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "a", "shift", "." ]

[ "sh", "1", "1", "1", "1", "2", "10000", "1", "1", "1", "1" ]

[]

[ "<s>", "unsigned", "ARM64TargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ")", "const", "{", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"sp\"", ",", "ARM64", "::", "SP", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "\"sp\"", "ARM64::SP", "0", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "static", "bool", "insn_is_function_arg", "(", "rtx", "insn", ",", "bool", "*", "is_spilled", ")", "{", "rtx", "dst", ";", "if", "(", "!", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "return", "false", ";", "if", "(", "CALL_P", "(", "insn", ")", ")", "return", "false", ";", "insn", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "PARALLEL", ")", "insn", "=", "XVECEXP", "(", "insn", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "insn", ")", "!=", "SET", ")", "return", "false", ";", "dst", "=", "SET_DEST", "(", "insn", ")", ";", "if", "(", "REG_P", "(", "dst", ")", "&&", "HARD_REGISTER_P", "(", "dst", ")", "&&", "ix86_function_arg_regno_p", "(", "REGNO", "(", "dst", ")", ")", ")", "{", "if", "(", "!", "TEST_HARD_REG_BIT", "(", "fixed_reg_set", ",", "REGNO", "(", "dst", ")", ")", "&&", "ix86_class_likely_spilled_p", "(", "REGNO_REG_CLASS", "(", "REGNO", "(", "dst", ")", ")", ")", ")", "*", "is_spilled", "=", "true", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "lhs", "of", "insn", "is", "HW", "function", "argument", "register", "and", "set", "up", "is_spilled", "to", "true", "if", "it", "is", "likely", "spilled", "HW", "register", "." ]

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

[]

[ "<s>", "bool", "MSP430DAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ";", "switch", "(", "ConstraintCode", ")", "{", "default", ":", "return", "true", ";", "case", "'m'", ":", "if", "(", "!", "SelectAddr", "(", "Op", ".", "getNode", "(", ")", ",", "Op", ",", "Op0", ",", "Op1", ")", ")", "return", "true", ";", "break", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "MSP430", "MSP430" ]

[]

[ "<s>", "void", "MipsDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "if", "(", "trySelect", "(", "Node", ")", ")", "return", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "ReplaceNode", "(", "Node", ",", "getGlobalBaseReg", "(", ")", ")", ";", "return", ";", "case", "ISD", "::", "LOAD", ":", "case", "ISD", "::", "STORE", ":", "assert", "(", "(", "Subtarget", "->", "systemSupportsUnalignedAccess", "(", ")", "||", "cast", "<", "MemSDNode", ">", "(", "Node", ")", "->", "getMemoryVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "8", "<=", "cast", "<", "MemSDNode", ">", "(", "Node", ")", "->", "getAlignment", "(", ")", ")", "&&", "\"Unexpected unaligned loads/stores.\"", ")", ";", "break", ";", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"== \"", "\"\\n\"", "1", "ISD::GLOBAL_OFFSET_TABLE", "ISD::LOAD", "ISD::STORE", "8", "\"Unexpected unaligned loads/stores.\"" ]

[]

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

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

[ "mproc", "mproc" ]

[]

[ "<s>", "bool", "Cpu0SETargetLowering", "::", "isEligibleForTailCallOptimization", "(", "const", "Cpu0CC", "&", "Cpu0CCInfo", ",", "unsigned", "NextStackOffset", ",", "const", "Cpu0MachineFunctionInfo", "&", "FI", ")", "const", "{", "if", "(", "!", "EnableCpu0TailCalls", ")", "return", "false", ";", "if", "(", "Cpu0CCInfo", ".", "hasByValArg", "(", ")", "||", "FI", ".", "hasByvalArg", "(", ")", ")", "return", "false", ";", "return", "NextStackOffset", "<=", "FI", ".", "getIncomingArgSize", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "call", "can", "be", "lowered", "as", "a", "tail", "call", "." ]

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

[]

[ "<s>", "static", "rtx", "rs6000_load_constant_and_splat", "(", "machine_mode", "mode", ",", "REAL_VALUE_TYPE", "dconst", ")", "{", "rtx", "reg", ";", "if", "(", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", ")", "{", "rtx", "d", "=", "const_double_from_real_value", "(", "dconst", ",", "mode", ")", ";", "reg", "=", "force_reg", "(", "mode", ",", "d", ")", ";", "}", "else", "if", "(", "mode", "==", "V4SFmode", ")", "{", "rtx", "d", "=", "const_double_from_real_value", "(", "dconst", ",", "SFmode", ")", ";", "rtvec", "v", "=", "gen_rtvec", "(", "4", ",", "d", ",", "d", ",", "d", ",", "d", ")", ";", "reg", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rs6000_expand_vector_init", "(", "reg", ",", "gen_rtx_PARALLEL", "(", "mode", ",", "v", ")", ")", ";", "}", "else", "if", "(", "mode", "==", "V2DFmode", ")", "{", "rtx", "d", "=", "const_double_from_real_value", "(", "dconst", ",", "DFmode", ")", ";", "rtvec", "v", "=", "gen_rtvec", "(", "2", ",", "d", ",", "d", ")", ";", "reg", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rs6000_expand_vector_init", "(", "reg", ",", "gen_rtx_PARALLEL", "(", "mode", ",", "v", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "return", "reg", ";", "}", "</s>" ]

[ "Load", "up", "a", "constant", ".", "If", "the", "mode", "is", "a", "vector", "mode", ",", "splat", "the", "value", "across", "all", "of", "the", "vector", "elements", "." ]

[ "rs6000", "4", "2" ]

[]

[ "<s>", "int", "m32r_legitimate_pic_operand_p", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "LABEL_REF", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "PIC", "." ]

[ "m32r", "0", "0", "0", "0", "0", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "bool", "X86CmovConverterPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "EnableCmovConverter", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** \"", "<<", "getPassName", "(", ")", "<<", "\" : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"**********\\n\"", ")", ";", "bool", "Changed", "=", "false", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "const", "TargetSubtargetInfo", "&", "STI", "=", "MF", ".", "getSubtarget", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "TSchedModel", ".", "init", "(", "&", "STI", ")", ";", "if", "(", "ForceMemOperand", "||", "ForceAll", ")", "{", "CmovGroups", "AllCmovGroups", ";", "SmallVector", "<", "MachineBasicBlock", "*", ",", "4", ">", "Blocks", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Blocks", ".", "push_back", "(", "&", "MBB", ")", ";", "if", "(", "collectCmovCandidates", "(", "Blocks", ",", "AllCmovGroups", ",", "true", ")", ")", "{", "for", "(", "auto", "&", "Group", ":", "AllCmovGroups", ")", "{", "if", "(", "ForceMemOperand", "&&", "!", "ForceAll", "&&", "llvm", "::", "none_of", "(", "Group", ",", "[", "&", "]", "(", "MachineInstr", "*", "I", ")", "{", "return", "I", "->", "mayLoad", "(", ")", ";", "}", ")", ")", "continue", ";", "Changed", "=", "true", ";", "convertCmovInstsToBranches", "(", "Group", ")", ";", "}", "}", "if", "(", "ForceAll", ")", "return", "Changed", ";", "}", "SmallVector", "<", "MachineLoop", "*", ",", "4", ">", "Loops", "(", "MLI", "->", "begin", "(", ")", ",", "MLI", "->", "end", "(", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "(", "int", ")", "Loops", ".", "size", "(", ")", ";", "++", "i", ")", "for", "(", "MachineLoop", "*", "Child", ":", "Loops", "[", "i", "]", "->", "getSubLoops", "(", ")", ")", "Loops", ".", "push_back", "(", "Child", ")", ";", "for", "(", "MachineLoop", "*", "CurrLoop", ":", "Loops", ")", "{", "if", "(", "!", "CurrLoop", "->", "getSubLoops", "(", ")", ".", "empty", "(", ")", ")", "continue", ";", "CmovGroups", "CmovInstGroups", ";", "if", "(", "!", "collectCmovCandidates", "(", "CurrLoop", "->", "getBlocks", "(", ")", ",", "CmovInstGroups", ")", ")", "continue", ";", "if", "(", "!", "checkForProfitableCmovCandidates", "(", "CurrLoop", "->", "getBlocks", "(", ")", ",", "CmovInstGroups", ")", ")", "continue", ";", "Changed", "=", "true", ";", "for", "(", "auto", "&", "Group", ":", "CmovInstGroups", ")", "convertCmovInstsToBranches", "(", "Group", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"********** \"", "\" : \"", "\"**********\\n\"", "4", "4", "0" ]

[]

[ "<s>", "Function", "*", "AMDGPUIntrinsicInfo", "::", "getDeclaration", "(", "Module", "*", "M", ",", "unsigned", "IntrID", ",", "Type", "*", "*", "Tys", ",", "unsigned", "numTys", ")", "const", "{", "llvm_unreachable", "(", "\"Not implemented\"", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\"Not implemented\"" ]

[]

[ "<s>", "void", "WebAssemblyDebugValueManager", "::", "clone", "(", "MachineInstr", "*", "Insert", ",", "unsigned", "NewReg", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "Insert", "->", "getParent", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "for", "(", "MachineInstr", "*", "DBI", ":", "reverse", "(", "DbgValues", ")", ")", "{", "MachineInstr", "*", "Clone", "=", "MF", "->", "CloneMachineInstr", "(", "DBI", ")", ";", "for", "(", "auto", "&", "MO", ":", "Clone", "->", "getDebugOperandsForReg", "(", "CurrentReg", ")", ")", "MO", ".", "setReg", "(", "NewReg", ")", ";", "MBB", "->", "insert", "(", "Insert", ",", "Clone", ")", ";", "}", "}", "</s>" ]

[ "Make", "a", "functionally", "equivalent", "copy", "of", "this", "MachineFunctionInfo", "in", "MF", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "bool", "Z80AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "return", "false", ";", "}", "</s>" ]

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

[ "Z80", "Z80" ]

[]

[ "<s>", "void", "PPCOperand", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "case", "Immediate", ":", "OS", "<<", "getImm", "(", ")", ";", "break", ";", "case", "Expression", ":", "getExpr", "(", ")", "->", "print", "(", "OS", ")", ";", "break", ";", "case", "TLSRegister", ":", "getTLSReg", "(", ")", "->", "print", "(", "OS", ")", ";", "break", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"'\"", "\"'\"" ]

[]

[ "<s>", "static", "void", "rs6000_emit_dot_insn", "(", "rtx", "dst", ",", "rtx", "src", ",", "int", "dot", ",", "rtx", "ccreg", ")", "{", "if", "(", "dot", "==", "0", ")", "{", "emit_move_insn", "(", "dst", ",", "src", ")", ";", "return", ";", "}", "if", "(", "cc_reg_not_cr0_operand", "(", "ccreg", ",", "CCmode", ")", ")", "{", "emit_move_insn", "(", "dst", ",", "src", ")", ";", "emit_move_insn", "(", "ccreg", ",", "gen_rtx_COMPARE", "(", "CCmode", ",", "dst", ",", "const0_rtx", ")", ")", ";", "return", ";", "}", "rtx", "ccset", "=", "gen_rtx_SET", "(", "ccreg", ",", "gen_rtx_COMPARE", "(", "CCmode", ",", "src", ",", "const0_rtx", ")", ")", ";", "if", "(", "dot", "==", "1", ")", "{", "rtx", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "dst", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "ccset", ",", "clobber", ")", ")", ")", ";", "}", "else", "{", "rtx", "set", "=", "gen_rtx_SET", "(", "dst", ",", "src", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "ccset", ",", "set", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "a", "potentially", "record-form", "instruction", ",", "setting", "DST", "from", "SRC", ".", "If", "DOT", "is", "0", ",", "that", "is", "all", ";", "otherwise", ",", "set", "CCREG", "to", "the", "result", "of", "the", "signed", "comparison", "of", "DST", "with", "zero", ".", "If", "DOT", "is", "1", ",", "the", "generated", "RTL", "does", "n't", "care", "about", "the", "DST", "result", ";", "if", "DOT", "is", "2", ",", "it", "does", ".", "If", "CCREG", "is", "CR0", "do", "a", "single", "dot", "insn", "(", "as", "a", "PARALLEL", ")", ";", "otherwise", ",", "do", "a", "SET", "and", "a", "separate", "COMPARE", "." ]

[ "powerpcspe", "0", "1", "2", "2" ]

[]

[ "<s>", "bool", "M68kCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ",", "Register", "SwiftErrorVReg", ")", "const", "{", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "M68k", "::", "RTS", ")", ";", "bool", "Success", "=", "true", ";", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "M68kTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "M68kTargetLowering", ">", "(", ")", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "getCCAssignFn", "(", "F", ".", "getCallingConv", "(", ")", ",", "true", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "if", "(", "!", "VRegs", ".", "empty", "(", ")", ")", "{", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "ArgInfo", "OrigArg", "{", "VRegs", ",", "Val", "->", "getType", "(", ")", ",", "0", "}", ";", "setArgFlags", "(", "OrigArg", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "F", ".", "getCallingConv", "(", ")", ")", ";", "OutgoingValueAssigner", "ArgAssigner", "(", "AssignFn", ")", ";", "M68kOutgoingArgHandler", "ArgHandler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ")", ";", "Success", "=", "determineAndHandleAssignments", "(", "ArgHandler", ",", "ArgAssigner", ",", "SplitArgs", ",", "MIRBuilder", ",", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "return", "Success", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "M68k", "M68k", "M68k::RTS", "M68k", "M68k", "8", "0", "M68k" ]

[]

[ "<s>", "static", "void", "ix86_avx256_split_vector_move_misalign", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "m", ";", "rtx", "(", "*", "extract", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "machine_mode", "mode", ";", "if", "(", "(", "MEM_P", "(", "op1", ")", "&&", "!", "TARGET_AVX256_SPLIT_UNALIGNED_LOAD", ")", "||", "(", "MEM_P", "(", "op0", ")", "&&", "!", "TARGET_AVX256_SPLIT_UNALIGNED_STORE", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "op1", ")", ")", ";", "return", ";", "}", "rtx", "orig_op0", "=", "NULL_RTX", ";", "mode", "=", "GET_MODE", "(", "op0", ")", ";", "switch", "(", "GET_MODE_CLASS", "(", "mode", ")", ")", "{", "case", "MODE_VECTOR_INT", ":", "case", "MODE_INT", ":", "if", "(", "mode", "!=", "V32QImode", ")", "{", "if", "(", "!", "MEM_P", "(", "op0", ")", ")", "{", "orig_op0", "=", "op0", ";", "op0", "=", "gen_reg_rtx", "(", "V32QImode", ")", ";", "}", "else", "op0", "=", "gen_lowpart", "(", "V32QImode", ",", "op0", ")", ";", "op1", "=", "gen_lowpart", "(", "V32QImode", ",", "op1", ")", ";", "mode", "=", "V32QImode", ";", "}", "break", ";", "case", "MODE_VECTOR_FLOAT", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "mode", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "V32QImode", ":", "extract", "=", "gen_avx_vextractf128v32qi", ";", "mode", "=", "V16QImode", ";", "break", ";", "case", "V8SFmode", ":", "extract", "=", "gen_avx_vextractf128v8sf", ";", "mode", "=", "V4SFmode", ";", "break", ";", "case", "V4DFmode", ":", "extract", "=", "gen_avx_vextractf128v4df", ";", "mode", "=", "V2DFmode", ";", "break", ";", "}", "if", "(", "MEM_P", "(", "op1", ")", ")", "{", "rtx", "r", "=", "gen_reg_rtx", "(", "mode", ")", ";", "m", "=", "adjust_address", "(", "op1", ",", "mode", ",", "0", ")", ";", "emit_move_insn", "(", "r", ",", "m", ")", ";", "m", "=", "adjust_address", "(", "op1", ",", "mode", ",", "16", ")", ";", "r", "=", "gen_rtx_VEC_CONCAT", "(", "GET_MODE", "(", "op0", ")", ",", "r", ",", "m", ")", ";", "emit_move_insn", "(", "op0", ",", "r", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "op0", ")", ")", "{", "m", "=", "adjust_address", "(", "op0", ",", "mode", ",", "0", ")", ";", "emit_insn", "(", "extract", "(", "m", ",", "op1", ",", "const0_rtx", ")", ")", ";", "m", "=", "adjust_address", "(", "op0", ",", "mode", ",", "16", ")", ";", "emit_insn", "(", "extract", "(", "m", ",", "copy_rtx", "(", "op1", ")", ",", "const1_rtx", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "orig_op0", ")", "emit_move_insn", "(", "orig_op0", ",", "gen_lowpart", "(", "GET_MODE", "(", "orig_op0", ")", ",", "op0", ")", ")", ";", "}", "</s>" ]

[ "Split", "32-byte", "AVX", "unaligned", "load", "and", "store", "if", "needed", "." ]

[ "i386", "0", "16", "0", "16" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "bool", "Result", "=", "AsmPrinter", "::", "runOnMachineFunction", "(", "F", ")", ";", "OutStreamer", "->", "EmitRawText", "(", "StringRef", "(", "\"}\\n\"", ")", ")", ";", "return", "Result", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "\"}\\n\"" ]

[]

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

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

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

[]

[ "<s>", "void", "HSAILPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createHSAILAlwaysInlinePass", "(", ")", ")", ";", "addPass", "(", "createAlwaysInlinerPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

[ "HSAIL", "HSAIL", "HSAIL" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"MSP430 Assembly Printer\"", ";", "}", "</s>" ]

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

[ "MSP430", "\"MSP430 Assembly Printer\"" ]

[]

[ "<s>", "char", "*", "emit_cond_move", "(", "rtx", "*", "operands", ",", "rtx", "insn", "ATTRIBUTE_UNUSED", ")", "{", "static", "char", "buffer", "[", "100", "]", ";", "const", "char", "*", "dest", "=", "reg_names", "[", "REGNO", "(", "operands", "[", "0", "]", ")", "]", ";", "buffer", "[", "0", "]", "=", "0", ";", "gcc_assert", "(", "REG_P", "(", "operands", "[", "0", "]", ")", ")", ";", "gcc_assert", "(", "conditional_move_operand", "(", "operands", "[", "2", "]", ",", "SImode", ")", ")", ";", "gcc_assert", "(", "conditional_move_operand", "(", "operands", "[", "3", "]", ",", "SImode", ")", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "NE", ")", "{", "rtx", "tmp", "=", "operands", "[", "2", "]", ";", "operands", "[", "2", "]", "=", "operands", "[", "3", "]", ";", "operands", "[", "3", "]", "=", "tmp", ";", "}", "sprintf", "(", "buffer", ",", "\"mvfc %s, cbr\"", ",", "dest", ")", ";", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "==", "0", ")", "sprintf", "(", "buffer", "+", "strlen", "(", "buffer", ")", ",", "\"\\n\\txor3 %s, %s, #1\"", ",", "dest", ",", "dest", ")", ";", "return", "buffer", ";", "}", "</s>" ]

[ "Generate", "the", "correct", "assembler", "code", "to", "handle", "the", "conditional", "loading", "of", "a", "value", "into", "a", "register", ".", "It", "is", "known", "that", "the", "operands", "satisfy", "the", "conditional_move_operand", "(", ")", "function", "above", ".", "The", "destination", "is", "operand", "[", "0", "]", ".", "The", "condition", "is", "operand", "[", "1", "]", ".", "The", "'true", "'", "value", "is", "operand", "[", "2", "]", "and", "the", "'false", "'", "value", "is", "operand", "[", "3", "]", "." ]

[ "m32r", "100", "0", "0", "0", "0", "2", "3", "1", "2", "2", "3", "3", "\"mvfc %s, cbr\"", "2", "0", "\"\\n\\txor3 %s, %s, #1\"" ]

[]

[ "<s>", "const", "char", "*", "output_sibcall", "(", "rtx_insn", "*", "insn", ",", "rtx", "call_operand", ")", "{", "rtx", "operands", "[", "1", "]", ";", "gcc_assert", "(", "flag_delayed_branch", ")", ";", "operands", "[", "0", "]", "=", "call_operand", ";", "if", "(", "sparc_leaf_function_p", "||", "TARGET_FLAT", ")", "{", "gcc_assert", "(", "!", "(", "LEAF_SIBCALL_SLOT_RESERVED_P", "&&", "final_sequence", ")", ")", ";", "if", "(", "final_sequence", ")", "output_asm_insn", "(", "\"sethi\\t%%hi(%a0), %%g1\\n\\tjmp\\t%%g1 + %%lo(%a0)%#\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"or\\t%%o7, %%g0, %%g1\\n\\tcall\\t%a0, 0\\n\\t or\\t%%g1, %%g0, %%o7\"", ",", "operands", ")", ";", "}", "else", "{", "output_asm_insn", "(", "\"call\\t%a0, 0\"", ",", "operands", ")", ";", "if", "(", "final_sequence", ")", "{", "rtx_insn", "*", "delay", "=", "NEXT_INSN", "(", "insn", ")", ";", "gcc_assert", "(", "delay", ")", ";", "output_restore", "(", "PATTERN", "(", "delay", ")", ")", ";", "PATTERN", "(", "delay", ")", "=", "gen_blockage", "(", ")", ";", "INSN_CODE", "(", "delay", ")", "=", "-", "1", ";", "}", "else", "output_restore", "(", "NULL_RTX", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "sibling", "call", "." ]

[ "sparc", "1", "0", "\"sethi\\t%%hi(%a0), %%g1\\n\\tjmp\\t%%g1 + %%lo(%a0)%#\"", "\"or\\t%%o7, %%g0, %%g1\\n\\tcall\\t%a0, 0\\n\\t or\\t%%g1, %%g0, %%o7\"", "\"call\\t%a0, 0\"", "1", "\"\"" ]

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "static", "rtx", "m32c_function_arg", "(", "cumulative_args_t", "ca_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "ca", "=", "get_cumulative_args", "(", "ca_v", ")", ";", "rtx", "rv", "=", "NULL_RTX", ";", "fprintf", "(", "stderr", ",", "\"func_arg %d (%s, %d)\\n\"", ",", "ca", "->", "parm_num", ",", "mode_name", "[", "mode", "]", ",", "named", ")", ";", "debug_tree", "(", "(", "tree", ")", "type", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "return", "GEN_INT", "(", "0", ")", ";", "if", "(", "ca", "->", "force_mem", "||", "!", "named", ")", "{", "fprintf", "(", "stderr", ",", "\"func arg: force %d named %d, mem\\n\"", ",", "ca", "->", "force_mem", ",", "named", ")", ";", "return", "NULL_RTX", ";", "}", "if", "(", "type", "&&", "INTEGRAL_TYPE_P", "(", "type", ")", "&&", "POINTER_TYPE_P", "(", "type", ")", ")", "return", "NULL_RTX", ";", "if", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "return", "NULL_RTX", ";", "switch", "(", "ca", "->", "parm_num", ")", "{", "case", "1", ":", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "1", "||", "GET_MODE_SIZE", "(", "mode", ")", "==", "2", ")", "rv", "=", "gen_rtx_REG", "(", "mode", ",", "TARGET_A16", "?", "R1_REGNO", ":", "R0_REGNO", ")", ";", "break", ";", "case", "2", ":", "if", "(", "TARGET_A16", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "2", ")", "rv", "=", "gen_rtx_REG", "(", "mode", ",", "R2_REGNO", ")", ";", "break", ";", "}", "debug_rtx", "(", "rv", ")", ";", "return", "rv", ";", "}", "</s>" ]

[ "Implements", "FUNCTION_ARG", ".", "Arguments", "are", "passed", "partly", "in", "registers", ",", "partly", "on", "stack", ".", "If", "our", "function", "returns", "a", "struct", ",", "a", "pointer", "to", "a", "buffer", "for", "it", "is", "at", "the", "top", "of", "the", "stack", "(", "last", "thing", "pushed", ")", ".", "The", "first", "few", "real", "arguments", "may", "be", "in", "registers", "as", "follows", ":", "R8C/M16C", ":", "arg1", "in", "r1", "if", "it", "'s", "QI", "or", "HI", "(", "else", "it", "'s", "pushed", "on", "stack", ")", "arg2", "in", "r2", "if", "it", "'s", "HI", "(", "else", "pushed", "on", "stack", ")", "rest", "on", "stack", "M32C", ":", "arg1", "in", "r0", "if", "it", "'s", "QI", "or", "HI", "(", "else", "it", "'s", "pushed", "on", "stack", ")", "rest", "on", "stack", "Structs", "are", "not", "passed", "in", "registers", ",", "even", "if", "they", "fit", ".", "Only", "integer", "and", "pointer", "types", "are", "passed", "in", "registers", ".", "Note", "that", "when", "arg1", "does", "n't", "fit", "in", "r1", ",", "arg2", "may", "still", "be", "passed", "in", "r2", "if", "it", "fits", "." ]

[ "m32c", "\"func_arg %d (%s, %d)\\n\"", "0", "\"func arg: force %d named %d, mem\\n\"", "1", "1", "2", "2", "2" ]

[]

[ "<s>", "bool", "SIWholeQuadMode", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Instructions", ".", "clear", "(", ")", ";", "Blocks", ".", "clear", "(", ")", ";", "LiveMaskQueries", ".", "clear", "(", ")", ";", "LowerToCopyInstrs", ".", "clear", "(", ")", ";", "CallingConv", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "char", "GlobalFlags", "=", "analyzeFunction", "(", "MF", ")", ";", "unsigned", "LiveMaskReg", "=", "0", ";", "unsigned", "Exec", "=", "ST", "->", "isWave32", "(", ")", "?", "AMDGPU", "::", "EXEC_LO", ":", "AMDGPU", "::", "EXEC", ";", "if", "(", "!", "(", "GlobalFlags", "&", "StateWQM", ")", ")", "{", "lowerLiveMaskQueries", "(", "Exec", ")", ";", "if", "(", "!", "(", "GlobalFlags", "&", "StateWWM", ")", "&&", "LowerToCopyInstrs", ".", "empty", "(", ")", ")", "return", "!", "LiveMaskQueries", ".", "empty", "(", ")", ";", "}", "else", "{", "MachineBasicBlock", "&", "Entry", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "EntryMI", "=", "Entry", ".", "getFirstNonPHI", "(", ")", ";", "if", "(", "GlobalFlags", "&", "StateExact", "||", "!", "LiveMaskQueries", ".", "empty", "(", ")", ")", "{", "LiveMaskReg", "=", "MRI", "->", "createVirtualRegister", "(", "TRI", "->", "getBoolRC", "(", ")", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "Entry", ",", "EntryMI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "COPY", ")", ",", "LiveMaskReg", ")", ".", "addReg", "(", "Exec", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "MI", ")", ";", "}", "lowerLiveMaskQueries", "(", "LiveMaskReg", ")", ";", "if", "(", "GlobalFlags", "==", "StateWQM", ")", "{", "BuildMI", "(", "Entry", ",", "EntryMI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ST", "->", "isWave32", "(", ")", "?", "AMDGPU", "::", "S_WQM_B32", ":", "AMDGPU", "::", "S_WQM_B64", ")", ",", "Exec", ")", ".", "addReg", "(", "Exec", ")", ";", "lowerCopyInstrs", "(", ")", ";", "return", "true", ";", "}", "}", "LLVM_DEBUG", "(", "printInfo", "(", ")", ")", ";", "lowerCopyInstrs", "(", ")", ";", "for", "(", "auto", "BII", ":", "Blocks", ")", "processBlock", "(", "*", "BII", ".", "first", ",", "LiveMaskReg", ",", "BII", ".", "first", "==", "&", "*", "MF", ".", "begin", "(", ")", ")", ";", "LIS", "->", "removeRegUnit", "(", "*", "MCRegUnitIterator", "(", "AMDGPU", "::", "SCC", ",", "TRI", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "0", "AMDGPU::EXEC_LO", "AMDGPU::EXEC", "AMDGPU::COPY", "AMDGPU::S_WQM_B32", "AMDGPU::S_WQM_B64", "AMDGPU::SCC" ]

[]

[ "<s>", "unsigned", "PIC16RegisterInfo", "::", "getFrameRegister", "(", "MachineFunction", "&", "MF", ")", "const", "{", "assert", "(", "0", "&&", "\"PIC16 Does not have any frame register\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "0", "\"PIC16 Does not have any frame register\"", "0" ]

[]

[ "<s>", "MVT", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", ",", "EVT", "VT", ")", "const", "override", "{", "return", "MVT", "::", "i8", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

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

[]

[ "<s>", "void", "sh_emit_compare_and_branch", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "0", "]", ")", ";", "enum", "rtx_code", "branch_code", ";", "rtx", "op0", "=", "operands", "[", "1", "]", ";", "rtx", "op1", "=", "operands", "[", "2", "]", ";", "rtx", "insn", ";", "bool", "need_ccmpeq", "=", "false", ";", "if", "(", "TARGET_SH2E", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "{", "op0", "=", "force_reg", "(", "mode", ",", "op0", ")", ";", "op1", "=", "force_reg", "(", "mode", ",", "op1", ")", ";", "}", "else", "{", "if", "(", "code", "!=", "EQ", "||", "mode", "==", "DImode", ")", "{", "op0", "=", "force_reg", "(", "mode", ",", "op0", ")", ";", "if", "(", "op1", "!=", "const0_rtx", "||", "code", "==", "GTU", "||", "code", "==", "GEU", ")", "op1", "=", "force_reg", "(", "mode", ",", "op1", ")", ";", "}", "}", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "{", "if", "(", "code", "==", "LT", "||", "(", "code", "==", "LE", "&&", "TARGET_IEEE", "&&", "TARGET_SH2E", ")", "||", "(", "code", "==", "GE", "&&", "!", "(", "TARGET_IEEE", "&&", "TARGET_SH2E", ")", ")", ")", "{", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "}", "if", "(", "code", "==", "GE", ")", "{", "gcc_assert", "(", "TARGET_IEEE", "&&", "TARGET_SH2E", ")", ";", "need_ccmpeq", "=", "true", ";", "code", "=", "GT", ";", "}", "gcc_assert", "(", "code", "==", "EQ", "||", "code", "==", "GT", "||", "code", "==", "NE", "||", "code", "==", "LE", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "GT", ":", "case", "GE", ":", "case", "GTU", ":", "case", "GEU", ":", "branch_code", "=", "code", ";", "break", ";", "case", "NE", ":", "case", "LT", ":", "case", "LE", ":", "case", "LTU", ":", "case", "LEU", ":", "branch_code", "=", "reverse_condition", "(", "code", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "insn", "=", "gen_rtx_SET", "(", "get_t_reg_rtx", "(", ")", ",", "gen_rtx_fmt_ee", "(", "branch_code", ",", "SImode", ",", "op0", ",", "op1", ")", ")", ";", "sh_emit_set_t_insn", "(", "insn", ",", "mode", ")", ";", "if", "(", "need_ccmpeq", ")", "sh_emit_set_t_insn", "(", "gen_ieee_ccmpeqsf_t", "(", "op0", ",", "op1", ")", ",", "mode", ")", ";", "if", "(", "branch_code", "==", "code", ")", "emit_jump_insn", "(", "gen_branch_true", "(", "operands", "[", "3", "]", ")", ")", ";", "else", "emit_jump_insn", "(", "gen_branch_false", "(", "operands", "[", "3", "]", ")", ")", ";", "}", "</s>" ]

[ "Called", "from", "the", "md", "file", ",", "set", "up", "the", "operands", "of", "a", "compare", "instruction", "." ]

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

[]

[ "<s>", "static", "void", "mips_insert_attributes", "(", "tree", "decl", ",", "tree", "*", "attributes", ")", "{", "const", "char", "*", "name", ";", "unsigned", "int", "compression_flags", ",", "nocompression_flags", ";", "compression_flags", "=", "mips_get_compress_on_flags", "(", "*", "attributes", ")", ";", "nocompression_flags", "=", "mips_get_compress_off_flags", "(", "*", "attributes", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "FUNCTION_DECL", ")", "{", "if", "(", "nocompression_flags", ")", "error", "(", "\"%qs attribute only applies to functions\"", ",", "mips_get_compress_off_name", "(", "nocompression_flags", ")", ")", ";", "if", "(", "compression_flags", ")", "error", "(", "\"%qs attribute only applies to functions\"", ",", "mips_get_compress_on_name", "(", "nocompression_flags", ")", ")", ";", "}", "else", "{", "compression_flags", "|=", "mips_get_compress_on_flags", "(", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ";", "nocompression_flags", "|=", "mips_get_compress_off_flags", "(", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ";", "if", "(", "compression_flags", "&&", "nocompression_flags", ")", "error", "(", "\"%qE cannot have both %qs and %qs attributes\"", ",", "DECL_NAME", "(", "decl", ")", ",", "mips_get_compress_on_name", "(", "compression_flags", ")", ",", "mips_get_compress_off_name", "(", "nocompression_flags", ")", ")", ";", "if", "(", "compression_flags", "&", "MASK_MIPS16", "&&", "compression_flags", "&", "MASK_MICROMIPS", ")", "error", "(", "\"%qE cannot have both %qs and %qs attributes\"", ",", "DECL_NAME", "(", "decl", ")", ",", "\"mips16\"", ",", "\"micromips\"", ")", ";", "if", "(", "TARGET_FLIP_MIPS16", "&&", "!", "DECL_ARTIFICIAL", "(", "decl", ")", "&&", "compression_flags", "==", "0", "&&", "nocompression_flags", "==", "0", ")", "{", "name", "=", "mflip_mips16_use_mips16_p", "(", "decl", ")", "?", "\"mips16\"", ":", "\"nomips16\"", ";", "*", "attributes", "=", "tree_cons", "(", "get_identifier", "(", "name", ")", ",", "NULL", ",", "*", "attributes", ")", ";", "name", "=", "\"nomicromips\"", ";", "*", "attributes", "=", "tree_cons", "(", "get_identifier", "(", "name", ")", ",", "NULL", ",", "*", "attributes", ")", ";", "}", "}", "}", "</s>" ]

[ "Implement", "TARGET_INSERT_ATTRIBUTES", "." ]

[ "mips", "\"%qs attribute only applies to functions\"", "\"%qs attribute only applies to functions\"", "\"%qE cannot have both %qs and %qs attributes\"", "\"%qE cannot have both %qs and %qs attributes\"", "\"mips16\"", "\"micromips\"", "0", "0", "\"mips16\"", "\"nomips16\"", "\"nomicromips\"" ]

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "requiresFrameIndexReplacementScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "MF", ".", "getFrameInfo", "(", ")", ".", "hasStackObjects", "(", ")", "&&", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ".", "hasScalarStores", "(", ")", "&&", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "hasSpilledSGPRs", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "using", "the", "RegScavenger", "directly", "for", "frame", "elimination", "despite", "using", "requiresFrameIndexScavenging", "." ]

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

[]

[ "<s>", "void", "X86InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "bool", "isAligned", "=", "(", "RI", ".", "getStackAlignment", "(", ")", ">=", "16", ")", "||", "RI", ".", "canRealignStack", "(", "MF", ")", ";", "unsigned", "Opc", "=", "getStoreRegOpcode", "(", "SrcReg", ",", "RC", ",", "isAligned", ",", "TM", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ")", ",", "FrameIdx", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "X86FastISel", "::", "tryToFoldLoadIntoMI", "(", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "LoadInst", "*", "LI", ")", "{", "const", "Value", "*", "Ptr", "=", "LI", "->", "getPointerOperand", "(", ")", ";", "X86AddressMode", "AM", ";", "if", "(", "!", "X86SelectAddress", "(", "Ptr", ",", "AM", ")", ")", "return", "false", ";", "const", "X86InstrInfo", "&", "XII", "=", "(", "const", "X86InstrInfo", "&", ")", "TII", ";", "unsigned", "Size", "=", "DL", ".", "getTypeAllocSize", "(", "LI", "->", "getType", "(", ")", ")", ";", "unsigned", "Alignment", "=", "LI", "->", "getAlignment", "(", ")", ";", "if", "(", "Alignment", "==", "0", ")", "Alignment", "=", "DL", ".", "getABITypeAlignment", "(", "LI", "->", "getType", "(", ")", ")", ";", "SmallVector", "<", "MachineOperand", ",", "8", ">", "AddrOps", ";", "AM", ".", "getFullAddress", "(", "AddrOps", ")", ";", "MachineInstr", "*", "Result", "=", "XII", ".", "foldMemoryOperandImpl", "(", "*", "FuncInfo", ".", "MF", ",", "MI", ",", "OpNo", ",", "AddrOps", ",", "Size", ",", "Alignment", ")", ";", "if", "(", "!", "Result", ")", "return", "false", ";", "Result", "->", "addMemOperand", "(", "*", "FuncInfo", ".", "MF", ",", "createMachineMemOperandFor", "(", "LI", ")", ")", ";", "FuncInfo", ".", "MBB", "->", "insert", "(", "FuncInfo", ".", "InsertPt", ",", "Result", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "The", "specified", "machine", "instr", "operand", "is", "a", "vreg", ",", "and", "that", "vreg", "is", "being", "provided", "by", "the", "specified", "load", "instruction", "." ]

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

[]

[ "<s>", "static", "unsigned", "HOST_WIDE_INT", "s390_asan_shadow_offset", "(", "void", ")", "{", "return", "TARGET_64BIT", "?", "HOST_WIDE_INT_1U", "<<", "52", ":", "HOST_WIDE_INT_UC", "(", "0x20000000", ")", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_ASAN_SHADOW_OFFSET", "hook", "." ]

[ "s390", "52", "0x20000000" ]

[]

[ "<s>", "rtx", "visium_dynamic_chain_address", "(", "rtx", "frame", ")", "{", "visium_frame_needed", "=", "true", ";", "return", "frame", ";", "}", "</s>" ]

[ "A", "C", "expression", "whose", "value", "is", "RTL", "representing", "the", "address", "in", "a", "stack", "frame", "where", "the", "pointer", "to", "the", "caller", "'s", "frame", "is", "stored", ".", "Assume", "that", "FRAMEADDR", "is", "an", "RTL", "expression", "for", "the", "address", "of", "the", "stack", "frame", "itself", ".", "If", "you", "do", "n't", "define", "this", "macro", ",", "the", "default", "is", "to", "return", "the", "value", "of", "FRAMEADDR", "--", "that", "is", ",", "the", "stack", "frame", "address", "is", "also", "the", "address", "of", "the", "stack", "word", "that", "points", "to", "the", "previous", "frame", "." ]

[ "visium" ]

[]

[ "<s>", "static", "rtx", "x86_this_parameter", "(", "tree", "function", ")", "{", "tree", "type", "=", "TREE_TYPE", "(", "function", ")", ";", "bool", "aggr", "=", "aggregate_value_p", "(", "TREE_TYPE", "(", "type", ")", ",", "type", ")", "!=", "0", ";", "int", "nregs", ";", "if", "(", "TARGET_64BIT", ")", "{", "const", "int", "*", "parm_regs", ";", "if", "(", "ix86_function_type_abi", "(", "type", ")", "==", "MS_ABI", ")", "parm_regs", "=", "x86_64_ms_abi_int_parameter_registers", ";", "else", "parm_regs", "=", "x86_64_int_parameter_registers", ";", "return", "gen_rtx_REG", "(", "Pmode", ",", "parm_regs", "[", "aggr", "]", ")", ";", "}", "nregs", "=", "ix86_function_regparm", "(", "type", ",", "function", ")", ";", "if", "(", "nregs", ">", "0", "&&", "!", "stdarg_p", "(", "type", ")", ")", "{", "int", "regno", ";", "unsigned", "int", "ccvt", "=", "ix86_get_callcvt", "(", "type", ")", ";", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_FASTCALL", ")", "!=", "0", ")", "regno", "=", "aggr", "?", "DX_REG", ":", "CX_REG", ";", "else", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_THISCALL", ")", "!=", "0", ")", "{", "regno", "=", "CX_REG", ";", "if", "(", "aggr", ")", "return", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "4", ")", ")", ";", "}", "else", "{", "regno", "=", "AX_REG", ";", "if", "(", "aggr", ")", "{", "regno", "=", "DX_REG", ";", "if", "(", "nregs", "==", "1", ")", "return", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "4", ")", ")", ";", "}", "}", "return", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "}", "return", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "aggr", "?", "8", ":", "4", ")", ")", ";", "}", "</s>" ]

[ "Returns", "an", "expression", "indicating", "where", "the", "this", "parameter", "is", "located", "on", "entry", "to", "the", "FUNCTION", "." ]

[ "i386", "0", "0", "0", "0", "4", "1", "4", "8", "4" ]

[]

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

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

[ "MOS" ]

[]

[ "<s>", "enum", "reg_class", "mips_secondary_reload_class", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", ")", "{", "int", "regno", ";", "if", "(", "mips_dangerous_for_la25_p", "(", "x", ")", ")", "return", "reg_class_subset_p", "(", "rclass", ",", "LEA_REGS", ")", "?", "NO_REGS", ":", "LEA_REGS", ";", "regno", "=", "true_regnum", "(", "x", ")", ";", "if", "(", "TARGET_MIPS16", ")", "{", "if", "(", "!", "reg_class_subset_p", "(", "rclass", ",", "M16_REGS", ")", "&&", "!", "M16_REG_P", "(", "regno", ")", ")", "return", "M16_REGS", ";", "return", "NO_REGS", ";", "}", "if", "(", "reg_class_subset_p", "(", "rclass", ",", "ACC_REGS", ")", ")", "return", "GP_REG_P", "(", "regno", ")", "?", "NO_REGS", ":", "GR_REGS", ";", "if", "(", "ACC_REG_P", "(", "regno", ")", ")", "return", "reg_class_subset_p", "(", "rclass", ",", "GR_REGS", ")", "?", "NO_REGS", ":", "GR_REGS", ";", "if", "(", "reg_class_subset_p", "(", "rclass", ",", "FP_REGS", ")", ")", "{", "if", "(", "regno", "<", "0", "||", "(", "MEM_P", "(", "x", ")", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "4", "||", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", ")", ")", "return", "NO_REGS", ";", "if", "(", "GP_REG_P", "(", "regno", ")", "||", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "NO_REGS", ";", "if", "(", "CONSTANT_P", "(", "x", ")", "&&", "!", "targetm", ".", "cannot_force_const_mem", "(", "mode", ",", "x", ")", ")", "return", "NO_REGS", ";", "if", "(", "FP_REG_P", "(", "regno", ")", "&&", "mips_mode_ok_for_mov_fmt_p", "(", "mode", ")", ")", "return", "NO_REGS", ";", "return", "GR_REGS", ";", "}", "if", "(", "FP_REG_P", "(", "regno", ")", ")", "return", "reg_class_subset_p", "(", "rclass", ",", "GR_REGS", ")", "?", "NO_REGS", ":", "GR_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "This", "function", "returns", "the", "register", "class", "required", "for", "a", "secondary", "register", "when", "copying", "between", "one", "of", "the", "registers", "in", "CLASS", ",", "and", "X", ",", "using", "MODE", ".", "If", "IN_P", "is", "nonzero", ",", "the", "copy", "is", "going", "from", "X", "to", "the", "register", ",", "otherwise", "the", "register", "is", "the", "source", ".", "A", "return", "value", "of", "NO_REGS", "means", "that", "no", "secondary", "register", "is", "required", "." ]

[ "mips", "0", "4", "8" ]

[]

[ "<s>", "int", "PPCTTIImpl", "::", "getIntImmCostInst", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "if", "(", "DisablePPCConstHoist", ")", "return", "BaseT", "::", "getIntImmCostInst", "(", "Opcode", ",", "Idx", ",", "Imm", ",", "Ty", ",", "CostKind", ")", ";", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "~", "0U", ";", "unsigned", "ImmIdx", "=", "~", "0U", ";", "bool", "ShiftedFree", "=", "false", ",", "RunFree", "=", "false", ",", "UnsignedFree", "=", "false", ",", "ZeroFree", "=", "false", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "GetElementPtr", ":", "if", "(", "Idx", "==", "0", ")", "return", "2", "*", "TTI", "::", "TCC_Basic", ";", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "And", ":", "RunFree", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "ShiftedFree", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Mul", ":", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "ImmIdx", "=", "1", ";", "break", ";", "case", "Instruction", "::", "ICmp", ":", "UnsignedFree", "=", "true", ";", "ImmIdx", "=", "1", ";", "LLVM_FALLTHROUGH", ";", "case", "Instruction", "::", "Select", ":", "ZeroFree", "=", "true", ";", "break", ";", "case", "Instruction", "::", "PHI", ":", "case", "Instruction", "::", "Call", ":", "case", "Instruction", "::", "Ret", ":", "case", "Instruction", "::", "Load", ":", "case", "Instruction", "::", "Store", ":", "break", ";", "}", "if", "(", "ZeroFree", "&&", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "Idx", "==", "ImmIdx", "&&", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", ")", "{", "if", "(", "isInt", "<", "16", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "RunFree", ")", "{", "if", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "32", "&&", "(", "isShiftedMask_32", "(", "Imm", ".", "getZExtValue", "(", ")", ")", "||", "isShiftedMask_32", "(", "~", "Imm", ".", "getZExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "ST", "->", "isPPC64", "(", ")", "&&", "(", "isShiftedMask_64", "(", "Imm", ".", "getZExtValue", "(", ")", ")", "||", "isShiftedMask_64", "(", "~", "Imm", ".", "getZExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "}", "if", "(", "UnsignedFree", "&&", "isUInt", "<", "16", ">", "(", "Imm", ".", "getZExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "ShiftedFree", "&&", "(", "Imm", ".", "getZExtValue", "(", ")", "&", "0xFFFF", ")", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "}", "return", "PPCTTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ";", "}", "</s>" ]

[ "Return", "the", "expected", "cost", "of", "materialization", "for", "the", "given", "integer", "immediate", "of", "the", "specified", "type", "for", "a", "given", "instruction", "." ]

[ "PowerPC", "PPC", "PPC", "0", "0U", "0U", "0", "2", "1", "1", "0", "64", "16", "32", "PPC", "16", "0xFFFF", "0", "PPC" ]

[]

[ "<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", "E_TImode", ":", "case", "E_DImode", ":", "case", "E_SImode", ":", "s390_expand_cs_tdsi", "(", "mode", ",", "btarget", ",", "vtarget", ",", "mem", ",", "cmp", ",", "new_rtx", ",", "is_weak", ")", ";", "break", ";", "case", "E_HImode", ":", "case", "E_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" ]

[]