Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "int", "ARMTTIImpl", "::", "getIntImmCost", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "if", "(", "(", "Opcode", "==", "Instruction", "::", "SDiv", "||", "Opcode", "==", "Instruction", "::", "UDiv", "||", "Opcode", "==", "Instruction", "::", "SRem", "||", "Opcode", "==", "Instruction", "::", "URem", ")", "&&", "Idx", "==", "1", ")", "return", "0", ";", "if", "(", "Opcode", "==", "Instruction", "::", "And", ")", "return", "std", "::", "min", "(", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ",", "getIntImmCost", "(", "~", "Imm", ",", "Ty", ")", ")", ";", "if", "(", "Opcode", "==", "Instruction", "::", "Add", ")", "return", "std", "::", "min", "(", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ",", "getIntImmCost", "(", "-", "Imm", ",", "Ty", ")", ")", ";", "if", "(", "Opcode", "==", "Instruction", "::", "ICmp", "&&", "Imm", ".", "isNegative", "(", ")", "&&", "Ty", "->", "getIntegerBitWidth", "(", ")", "==", "32", ")", "{", "int64_t", "NegImm", "=", "-", "Imm", ".", "getSExtValue", "(", ")", ";", "if", "(", "ST", "->", "isThumb2", "(", ")", "&&", "NegImm", "<", "1", "<<", "12", ")", "return", "0", ";", "if", "(", "ST", "->", "isThumb", "(", ")", "&&", "NegImm", "<", "1", "<<", "8", ")", "return", "0", ";", "}", "return", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "1", "0", "32", "1", "12", "0", "1", "8", "0" ]

[]

[ "<s>", "static", "bool", "is_imported_p", "(", "rtx", "x", ")", "{", "if", "(", "!", "TARGET_DLLIMPORT_DECL_ATTRIBUTES", "||", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", ")", "return", "false", ";", "return", "SYMBOL_REF_DLLIMPORT_P", "(", "x", ")", "||", "SYMBOL_REF_STUBVAR_P", "(", "x", ")", ";", "}", "</s>" ]

[ "Nonzero", "if", "the", "symbol", "is", "marked", "as", "dllimport", ",", "or", "as", "stub-variable", ",", "otherwise", "zero", "." ]

[ "i386" ]

[]

[ "<s>", "const", "RegisterBankInfo", "*", "getRegBankInfo", "(", ")", "const", "override", "{", "return", "RegBankInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "If", "the", "information", "for", "the", "register", "banks", "is", "available", ",", "return", "it", "." ]

[ "SPIRV" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "MachineInstr", "&", "MIa", ",", "MachineInstr", "&", "MIb", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "assert", "(", "(", "MIa", ".", "mayLoad", "(", ")", "||", "MIa", ".", "mayStore", "(", ")", ")", "&&", "\"MIa must load from or modify a memory location\"", ")", ";", "assert", "(", "(", "MIb", ".", "mayLoad", "(", ")", "||", "MIb", ".", "mayStore", "(", ")", ")", "&&", "\"MIb must load from or modify a memory location\"", ")", ";", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", ")", "return", "false", ";", "if", "(", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "AA", "&&", "MIa", ".", "hasOneMemOperand", "(", ")", "&&", "MIb", ".", "hasOneMemOperand", "(", ")", ")", "{", "const", "MachineMemOperand", "*", "MMOa", "=", "*", "MIa", ".", "memoperands_begin", "(", ")", ";", "const", "MachineMemOperand", "*", "MMOb", "=", "*", "MIb", ".", "memoperands_begin", "(", ")", ";", "if", "(", "MMOa", "->", "getValue", "(", ")", "&&", "MMOb", "->", "getValue", "(", ")", ")", "{", "MemoryLocation", "LocA", "(", "MMOa", "->", "getValue", "(", ")", ",", "MMOa", "->", "getSize", "(", ")", ",", "MMOa", "->", "getAAInfo", "(", ")", ")", ";", "MemoryLocation", "LocB", "(", "MMOb", "->", "getValue", "(", ")", ",", "MMOb", "->", "getSize", "(", ")", ",", "MMOb", "->", "getAAInfo", "(", ")", ")", ";", "if", "(", "!", "AA", "->", "alias", "(", "LocA", ",", "LocB", ")", ")", "return", "true", ";", "}", "}", "if", "(", "isDS", "(", "MIa", ")", ")", "{", "if", "(", "isDS", "(", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "!", "isFLAT", "(", "MIb", ")", ";", "}", "if", "(", "isMUBUF", "(", "MIa", ")", "||", "isMTBUF", "(", "MIa", ")", ")", "{", "if", "(", "isMUBUF", "(", "MIb", ")", "||", "isMTBUF", "(", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "!", "isFLAT", "(", "MIb", ")", "&&", "!", "isSMRD", "(", "MIb", ")", ";", "}", "if", "(", "isSMRD", "(", "MIa", ")", ")", "{", "if", "(", "isSMRD", "(", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "!", "isFLAT", "(", "MIb", ")", "&&", "!", "isMUBUF", "(", "MIa", ")", "&&", "!", "isMTBUF", "(", "MIa", ")", ";", "}", "if", "(", "isFLAT", "(", "MIa", ")", ")", "{", "if", "(", "isFLAT", "(", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "SIInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "auto", "E", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "E", ")", "return", "false", ";", "while", "(", "I", "!=", "E", "&&", "!", "I", "->", "isBranch", "(", ")", "&&", "!", "I", "->", "isReturn", "(", ")", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "S_MOV_B64_term", ":", "case", "AMDGPU", "::", "S_XOR_B64_term", ":", "case", "AMDGPU", "::", "S_OR_B64_term", ":", "case", "AMDGPU", "::", "S_ANDN2_B64_term", ":", "case", "AMDGPU", "::", "S_AND_B64_term", ":", "case", "AMDGPU", "::", "S_MOV_B32_term", ":", "case", "AMDGPU", "::", "S_XOR_B32_term", ":", "case", "AMDGPU", "::", "S_OR_B32_term", ":", "case", "AMDGPU", "::", "S_ANDN2_B32_term", ":", "case", "AMDGPU", "::", "S_AND_B32_term", ":", "break", ";", "case", "AMDGPU", "::", "SI_IF", ":", "case", "AMDGPU", "::", "SI_ELSE", ":", "case", "AMDGPU", "::", "SI_KILL_I1_TERMINATOR", ":", "case", "AMDGPU", "::", "SI_KILL_F32_COND_IMM_TERMINATOR", ":", "return", "true", ";", "default", ":", "llvm_unreachable", "(", "\"unexpected non-branch terminator inst\"", ")", ";", "}", "++", "I", ";", "}", "if", "(", "I", "==", "E", ")", "return", "false", ";", "return", "analyzeBranchImpl", "(", "MBB", ",", "I", ",", "TBB", ",", "FBB", ",", "Cond", ",", "AllowModify", ")", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "AMDGPU", "SI", "AMDGPU::S_MOV_B64_term", "AMDGPU::S_XOR_B64_term", "AMDGPU::S_OR_B64_term", "AMDGPU::S_ANDN2_B64_term", "AMDGPU::S_AND_B64_term", "AMDGPU::S_MOV_B32_term", "AMDGPU::S_XOR_B32_term", "AMDGPU::S_OR_B32_term", "AMDGPU::S_ANDN2_B32_term", "AMDGPU::S_AND_B32_term", "AMDGPU::SI_IF", "AMDGPU::SI_ELSE", "AMDGPU::SI_KILL_I1_TERMINATOR", "AMDGPU::SI_KILL_F32_COND_IMM_TERMINATOR", "\"unexpected non-branch terminator inst\"" ]

[]

[ "<s>", "static", "bool", "aarch64_can_inline_p", "(", "tree", "caller", ",", "tree", "callee", ")", "{", "tree", "caller_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "caller", ")", ";", "tree", "callee_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "callee", ")", ";", "struct", "cl_target_option", "*", "caller_opts", "=", "TREE_TARGET_OPTION", "(", "caller_tree", "?", "caller_tree", ":", "target_option_default_node", ")", ";", "struct", "cl_target_option", "*", "callee_opts", "=", "TREE_TARGET_OPTION", "(", "callee_tree", "?", "callee_tree", ":", "target_option_default_node", ")", ";", "if", "(", "(", "caller_opts", "->", "x_aarch64_isa_flags", "&", "callee_opts", "->", "x_aarch64_isa_flags", ")", "!=", "callee_opts", "->", "x_aarch64_isa_flags", ")", "return", "false", ";", "if", "(", "(", "TARGET_STRICT_ALIGN_P", "(", "caller_opts", "->", "x_target_flags", ")", "!=", "TARGET_STRICT_ALIGN_P", "(", "callee_opts", "->", "x_target_flags", ")", ")", "&&", "!", "(", "!", "TARGET_STRICT_ALIGN_P", "(", "callee_opts", "->", "x_target_flags", ")", "&&", "TARGET_STRICT_ALIGN_P", "(", "caller_opts", "->", "x_target_flags", ")", ")", ")", "return", "false", ";", "bool", "always_inline", "=", "lookup_attribute", "(", "\"always_inline\"", ",", "DECL_ATTRIBUTES", "(", "callee", ")", ")", ";", "if", "(", "always_inline", ")", "return", "true", ";", "if", "(", "caller_opts", "->", "x_aarch64_cmodel_var", "!=", "callee_opts", "->", "x_aarch64_cmodel_var", ")", "return", "false", ";", "if", "(", "caller_opts", "->", "x_aarch64_tls_dialect", "!=", "callee_opts", "->", "x_aarch64_tls_dialect", ")", "return", "false", ";", "if", "(", "!", "aarch64_tribools_ok_for_inlining_p", "(", "caller_opts", "->", "x_aarch64_fix_a53_err835769", ",", "callee_opts", "->", "x_aarch64_fix_a53_err835769", ",", "2", ",", "TARGET_FIX_ERR_A53_835769_DEFAULT", ")", ")", "return", "false", ";", "if", "(", "!", "aarch64_tribools_ok_for_inlining_p", "(", "caller_opts", "->", "x_aarch64_fix_a53_err843419", ",", "callee_opts", "->", "x_aarch64_fix_a53_err843419", ",", "2", ",", "TARGET_FIX_ERR_A53_843419", ")", ")", "return", "false", ";", "if", "(", "!", "aarch64_tribools_ok_for_inlining_p", "(", "caller_opts", "->", "x_flag_omit_leaf_frame_pointer", ",", "callee_opts", "->", "x_flag_omit_leaf_frame_pointer", ",", "2", ",", "1", ")", ")", "return", "false", ";", "if", "(", "callee_opts", "->", "x_aarch64_override_tune_string", "!=", "NULL", "&&", "caller_opts", "->", "x_aarch64_override_tune_string", "==", "NULL", ")", "return", "false", ";", "if", "(", "callee_opts", "->", "x_aarch64_override_tune_string", "&&", "caller_opts", "->", "x_aarch64_override_tune_string", "&&", "(", "strcmp", "(", "callee_opts", "->", "x_aarch64_override_tune_string", ",", "caller_opts", "->", "x_aarch64_override_tune_string", ")", "!=", "0", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_INLINE_P", ".", "Decide", "whether", "it", "is", "valid", "to", "inline", "CALLEE", "into", "CALLER", "based", "on", "target-specific", "info", ".", "Make", "sure", "that", "the", "caller", "and", "callee", "have", "compatible", "architectural", "features", ".", "Then", "go", "through", "the", "other", "possible", "target", "attributes", "and", "see", "if", "they", "can", "block", "inlining", ".", "Try", "not", "to", "reject", "always_inline", "callees", "unless", "they", "are", "incompatible", "architecturally", "." ]

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

[]

[ "<s>", "bool", "getAlign", "(", "const", "Function", "&", "F", ",", "unsigned", "index", ",", "unsigned", "&", "align", ")", "{", "std", "::", "vector", "<", "unsigned", ">", "Vs", ";", "bool", "retval", "=", "findAllNVVMAnnotation", "(", "&", "F", ",", "\"align\"", ",", "Vs", ")", ";", "if", "(", "!", "retval", ")", "return", "false", ";", "for", "(", "int", "i", "=", "0", ",", "e", "=", "Vs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "i", "++", ")", "{", "unsigned", "v", "=", "Vs", "[", "i", "]", ";", "if", "(", "(", "v", ">>", "16", ")", "==", "index", ")", "{", "align", "=", "v", "&", "0xFFFF", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "the", "minimum", "known", "alignment", "in", "bytes", "of", "the", "actual", "memory", "reference", "." ]

[ "NVPTX", "\"align\"", "0", "16", "0xFFFF" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "MipsMCSymbolRefExpr", "*", ")", "{", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "unsigned", "getMaxCallFrameSize", "(", ")", "const", "{", "return", "MaxCallFrameSize", ";", "}", "</s>" ]

[ "Return", "the", "maximum", "size", "of", "a", "call", "frame", "that", "must", "be", "allocated", "for", "an", "outgoing", "function", "call", "." ]

[ "Cpu0" ]

[]

[ "<s>", "static", "void", "msp430_compute_frame_info", "(", "void", ")", "{", "int", "i", ";", "cfun", "->", "machine", "->", "computed", "=", "1", ";", "cfun", "->", "machine", "->", "framesize_regs", "=", "0", ";", "cfun", "->", "machine", "->", "framesize_locals", "=", "get_frame_size", "(", ")", ";", "cfun", "->", "machine", "->", "framesize_outgoing", "=", "crtl", "->", "outgoing_args_size", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARG_POINTER_REGNUM", ";", "i", "++", ")", "if", "(", "msp430_preserve_reg_p", "(", "i", ")", ")", "{", "cfun", "->", "machine", "->", "need_to_save", "[", "i", "]", "=", "1", ";", "cfun", "->", "machine", "->", "framesize_regs", "+=", "(", "TARGET_LARGE", "?", "4", ":", "2", ")", ";", "}", "else", "cfun", "->", "machine", "->", "need_to_save", "[", "i", "]", "=", "0", ";", "if", "(", "(", "cfun", "->", "machine", "->", "framesize_locals", "+", "cfun", "->", "machine", "->", "framesize_outgoing", ")", "&", "1", ")", "cfun", "->", "machine", "->", "framesize_locals", "++", ";", "cfun", "->", "machine", "->", "framesize", "=", "(", "cfun", "->", "machine", "->", "framesize_regs", "+", "cfun", "->", "machine", "->", "framesize_locals", "+", "cfun", "->", "machine", "->", "framesize_outgoing", ")", ";", "}", "</s>" ]

[ "Compute", "all", "the", "frame-related", "fields", "in", "our", "machine_function", "structure", "." ]

[ "msp430", "1", "0", "0", "1", "4", "2", "0", "1" ]

[]

[ "<s>", "WebAssemblySubtarget", "::", "WebAssemblySubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ")", ":", "WebAssemblyGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "HasSIMD128", "(", "false", ")", ",", "HasAtomics", "(", "false", ")", ",", "HasNontrappingFPToInt", "(", "false", ")", ",", "CPUString", "(", "CPU", ")", ",", "TargetTriple", "(", "TT", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "FS", ")", ")", ",", "TSInfo", "(", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "ix86_function_sseregparm", "(", "const_tree", "type", ",", "const_tree", "decl", ",", "bool", "warn", ")", "{", "gcc_assert", "(", "!", "TARGET_64BIT", ")", ";", "if", "(", "TARGET_SSEREGPARM", "||", "(", "type", "&&", "lookup_attribute", "(", "\"sseregparm\"", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ")", ")", "{", "if", "(", "!", "TARGET_SSE", ")", "{", "if", "(", "warn", ")", "{", "if", "(", "decl", ")", "error", "(", "\"calling %qD with attribute sseregparm without \"", "\"SSE/SSE2 enabled\"", ",", "decl", ")", ";", "else", "error", "(", "\"calling %qT with attribute sseregparm without \"", "\"SSE/SSE2 enabled\"", ",", "type", ")", ";", "}", "return", "0", ";", "}", "return", "2", ";", "}", "if", "(", "!", "decl", ")", "return", "0", ";", "cgraph_node", "*", "target", "=", "cgraph_node", "::", "get", "(", "decl", ")", ";", "if", "(", "target", ")", "target", "=", "target", "->", "function_symbol", "(", ")", ";", "if", "(", "target", "&&", "(", "target_opts_for_fn", "(", "target", "->", "decl", ")", "->", "x_ix86_fpmath", "&", "FPMATH_SSE", ")", "&&", "opt_for_fn", "(", "target", "->", "decl", ",", "optimize", ")", "&&", "!", "(", "profile_flag", "&&", "!", "flag_fentry", ")", ")", "{", "cgraph_local_info", "*", "i", "=", "&", "target", "->", "local", ";", "if", "(", "i", "&&", "i", "->", "local", "&&", "i", "->", "can_change_signature", ")", "{", "if", "(", "!", "TARGET_SSE", "&&", "warn", ")", "return", "-", "1", ";", "return", "TARGET_SSE2_P", "(", "target_opts_for_fn", "(", "target", "->", "decl", ")", "->", "x_ix86_isa_flags", ")", "?", "2", ":", "1", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "or", "2", ",", "if", "we", "can", "pass", "up", "to", "SSE_REGPARM_MAX", "SFmode", "(", "1", ")", "and", "DFmode", "(", "2", ")", "arguments", "in", "SSE", "registers", "for", "a", "function", "with", "the", "indicated", "TYPE", "and", "DECL", ".", "DECL", "may", "be", "NULL", "when", "calling", "function", "indirectly", "or", "considering", "a", "libcall", ".", "Otherwise", "return", "0", "." ]

[ "i386", "\"sseregparm\"", "\"calling %qD with attribute sseregparm without \"", "\"SSE/SSE2 enabled\"", "\"calling %qT with attribute sseregparm without \"", "\"SSE/SSE2 enabled\"", "0", "2", "0", "1", "2", "1", "0" ]

[]

[ "<s>", "static", "void", "rs6000_emit_nmsub", "(", "rtx", "dst", ",", "rtx", "m1", ",", "rtx", "m2", ",", "rtx", "a", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dst", ")", ";", "rtx", "r", ";", "gcc_assert", "(", "optab_handler", "(", "fma_optab", ",", "mode", ")", "!=", "CODE_FOR_nothing", ")", ";", "r", "=", "gen_rtx_NEG", "(", "mode", ",", "a", ")", ";", "r", "=", "gen_rtx_FMA", "(", "mode", ",", "m1", ",", "m2", ",", "r", ")", ";", "r", "=", "gen_rtx_NEG", "(", "mode", ",", "r", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dst", ",", "r", ")", ")", ";", "}", "</s>" ]

[ "Generate", "a", "FNMSUB", "instruction", ":", "dst", "=", "-fma", "(", "m1", ",", "m2", ",", "-a", ")", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "static", "rtx", "sparc_legitimize_pic_address", "(", "rtx", "orig", ",", "rtx", "reg", ")", "{", "bool", "gotdata_op", "=", "false", ";", "if", "(", "GET_CODE", "(", "orig", ")", "==", "SYMBOL_REF", "||", "(", "GET_CODE", "(", "orig", ")", "==", "LABEL_REF", "&&", "!", "can_use_mov_pic_label_ref", "(", "orig", ")", ")", ")", "{", "rtx", "pic_ref", ",", "address", ";", "rtx_insn", "*", "insn", ";", "if", "(", "reg", "==", "0", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "}", "if", "(", "flag_pic", "==", "2", ")", "{", "rtx", "temp_reg", "=", "(", "!", "can_create_pseudo_p", "(", ")", "?", "reg", ":", "gen_reg_rtx", "(", "Pmode", ")", ")", ";", "if", "(", "TARGET_ARCH64", ")", "{", "emit_insn", "(", "gen_movdi_high_pic", "(", "temp_reg", ",", "orig", ")", ")", ";", "emit_insn", "(", "gen_movdi_lo_sum_pic", "(", "temp_reg", ",", "temp_reg", ",", "orig", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_movsi_high_pic", "(", "temp_reg", ",", "orig", ")", ")", ";", "emit_insn", "(", "gen_movsi_lo_sum_pic", "(", "temp_reg", ",", "temp_reg", ",", "orig", ")", ")", ";", "}", "address", "=", "temp_reg", ";", "gotdata_op", "=", "true", ";", "}", "else", "address", "=", "orig", ";", "crtl", "->", "uses_pic_offset_table", "=", "1", ";", "if", "(", "gotdata_op", ")", "{", "if", "(", "TARGET_ARCH64", ")", "insn", "=", "emit_insn", "(", "gen_movdi_pic_gotdata_op", "(", "reg", ",", "pic_offset_table_rtx", ",", "address", ",", "orig", ")", ")", ";", "else", "insn", "=", "emit_insn", "(", "gen_movsi_pic_gotdata_op", "(", "reg", ",", "pic_offset_table_rtx", ",", "address", ",", "orig", ")", ")", ";", "}", "else", "{", "pic_ref", "=", "gen_const_mem", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "pic_offset_table_rtx", ",", "address", ")", ")", ";", "insn", "=", "emit_move_insn", "(", "reg", ",", "pic_ref", ")", ";", "}", "set_unique_reg_note", "(", "insn", ",", "REG_EQUAL", ",", "orig", ")", ";", "return", "reg", ";", "}", "else", "if", "(", "GET_CODE", "(", "orig", ")", "==", "CONST", ")", "{", "rtx", "base", ",", "offset", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "orig", ",", "0", ")", ")", "==", "PLUS", "&&", "XEXP", "(", "XEXP", "(", "orig", ",", "0", ")", ",", "0", ")", "==", "pic_offset_table_rtx", ")", "return", "orig", ";", "if", "(", "reg", "==", "0", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "orig", ",", "0", ")", ")", "==", "PLUS", ")", ";", "base", "=", "sparc_legitimize_pic_address", "(", "XEXP", "(", "XEXP", "(", "orig", ",", "0", ")", ",", "0", ")", ",", "reg", ")", ";", "offset", "=", "sparc_legitimize_pic_address", "(", "XEXP", "(", "XEXP", "(", "orig", ",", "0", ")", ",", "1", ")", ",", "base", "==", "reg", "?", "NULL_RTX", ":", "reg", ")", ";", "if", "(", "GET_CODE", "(", "offset", ")", "==", "CONST_INT", ")", "{", "if", "(", "SMALL_INT", "(", "offset", ")", ")", "return", "plus_constant", "(", "Pmode", ",", "base", ",", "INTVAL", "(", "offset", ")", ")", ";", "else", "if", "(", "can_create_pseudo_p", "(", ")", ")", "offset", "=", "force_reg", "(", "Pmode", ",", "offset", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "base", ",", "offset", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "orig", ")", "==", "LABEL_REF", ")", "crtl", "->", "uses_pic_offset_table", "=", "1", ";", "return", "orig", ";", "}", "</s>" ]

[ "Legitimize", "PIC", "addresses", ".", "If", "the", "address", "is", "already", "position-independent", ",", "we", "return", "ORIG", ".", "Newly", "generated", "position-independent", "addresses", "go", "into", "a", "reg", ".", "This", "is", "REG", "if", "nonzero", ",", "otherwise", "we", "allocate", "register", "(", "s", ")", "as", "necessary", "." ]

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

[]

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

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

[ "ARM64" ]

[]

[ "<s>", "int", "getIntImmCost", "(", "Intrinsic", "::", "ID", "IID", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "return", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

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

[ "DLX", "Intrinsic::ID" ]

[]

[ "<s>", "static", "bool", "rs6000_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "RELOCATABLE_NEEDS_FIXUP", "&&", "size", "==", "4", "&&", "aligned_p", ")", "{", "static", "int", "recurse", "=", "0", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "(", "TARGET_RELOCATABLE", "||", "flag_pic", ">", "1", ")", "&&", "in_section", "!=", "toc_section", "&&", "!", "recurse", "&&", "!", "CONST_SCALAR_INT_P", "(", "x", ")", "&&", "CONSTANT_P", "(", "x", ")", ")", "{", "char", "buf", "[", "256", "]", ";", "recurse", "=", "1", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"LCP\"", ",", "fixuplabelno", ")", ";", "fixuplabelno", "++", ";", "ASM_OUTPUT_LABEL", "(", "asm_out_file", ",", "buf", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.long\\t(\"", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fprintf", "(", "asm_out_file", ",", "\")@fixup\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.section\\t\\\".fixup\\\",\\\"aw\\\"\\n\"", ")", ";", "ASM_OUTPUT_ALIGN", "(", "asm_out_file", ",", "2", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.long\\t\"", ")", ";", "assemble_name", "(", "asm_out_file", ",", "buf", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\n\\t.previous\\n\"", ")", ";", "recurse", "=", "0", ";", "return", "true", ";", "}", "else", "if", "(", "SYMBOL_REF_P", "(", "x", ")", "&&", "XSTR", "(", "x", ",", "0", ")", "[", "0", "]", "==", "'.'", "&&", "DEFAULT_ABI", "==", "ABI_AIX", ")", "{", "const", "char", "*", "name", "=", "XSTR", "(", "x", ",", "0", ")", ";", "while", "(", "*", "name", "==", "'.'", ")", "name", "++", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.long\\t%s\\n\"", ",", "name", ")", ";", "return", "true", ";", "}", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "assembling", "integer", "objects", ".", "The", "powerpc", "version", "has", "to", "handle", "fixup", "entries", "for", "relocatable", "code", "if", "RELOCATABLE_NEEDS_FIXUP", "is", "defined", ".", "It", "also", "needs", "to", "handle", "DI-mode", "objects", "on", "64-bit", "targets", "." ]

[ "rs6000", "4", "0", "1", "256", "1", "\"LCP\"", "\"\\t.long\\t(\"", "\")@fixup\\n\"", "\"\\t.section\\t\\\".fixup\\\",\\\"aw\\\"\\n\"", "2", "\"\\t.long\\t\"", "\"\\n\\t.previous\\n\"", "0", "0", "0", "0", "\"\\t.long\\t%s\\n\"" ]

[]

[ "<s>", "static", "void", "lm32_block_move_inline", "(", "rtx", "dest", ",", "rtx", "src", ",", "HOST_WIDE_INT", "length", ",", "HOST_WIDE_INT", "alignment", ")", "{", "HOST_WIDE_INT", "offset", ",", "delta", ";", "unsigned", "HOST_WIDE_INT", "bits", ";", "int", "i", ";", "machine_mode", "mode", ";", "rtx", "*", "regs", ";", "switch", "(", "alignment", ")", "{", "case", "1", ":", "bits", "=", "8", ";", "break", ";", "case", "2", ":", "bits", "=", "16", ";", "break", ";", "default", ":", "bits", "=", "32", ";", "break", ";", "}", "mode", "=", "mode_for_size", "(", "bits", ",", "MODE_INT", ",", "0", ")", ";", "delta", "=", "bits", "/", "BITS_PER_UNIT", ";", "regs", "=", "XALLOCAVEC", "(", "rtx", ",", "length", "/", "delta", ")", ";", "for", "(", "offset", "=", "0", ",", "i", "=", "0", ";", "offset", "+", "delta", "<=", "length", ";", "offset", "+=", "delta", ",", "i", "++", ")", "{", "regs", "[", "i", "]", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_move_insn", "(", "regs", "[", "i", "]", ",", "adjust_address", "(", "src", ",", "mode", ",", "offset", ")", ")", ";", "}", "for", "(", "offset", "=", "0", ",", "i", "=", "0", ";", "offset", "+", "delta", "<=", "length", ";", "offset", "+=", "delta", ",", "i", "++", ")", "emit_move_insn", "(", "adjust_address", "(", "dest", ",", "mode", ",", "offset", ")", ",", "regs", "[", "i", "]", ")", ";", "if", "(", "offset", "<", "length", ")", "{", "src", "=", "adjust_address", "(", "src", ",", "BLKmode", ",", "offset", ")", ";", "dest", "=", "adjust_address", "(", "dest", ",", "BLKmode", ",", "offset", ")", ";", "move_by_pieces", "(", "dest", ",", "src", ",", "length", "-", "offset", ",", "MIN", "(", "MEM_ALIGN", "(", "src", ")", ",", "MEM_ALIGN", "(", "dest", ")", ")", ",", "0", ")", ";", "}", "}", "</s>" ]

[ "Emit", "straight-line", "code", "to", "move", "LENGTH", "bytes", "from", "SRC", "to", "DEST", ".", "Assume", "that", "the", "areas", "do", "not", "overlap", "." ]

[ "lm32", "1", "8", "2", "16", "32", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "invalid_e500_subreg", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_E500_DOUBLE", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "SUBREG", "&&", "(", "mode", "==", "SImode", "||", "mode", "==", "DImode", "||", "mode", "==", "TImode", "||", "mode", "==", "DDmode", "||", "mode", "==", "TDmode", "||", "mode", "==", "PTImode", ")", "&&", "REG_P", "(", "SUBREG_REG", "(", "op", ")", ")", "&&", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "DFmode", "||", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "TFmode", "||", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "IFmode", "||", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "KFmode", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SUBREG", "&&", "(", "mode", "==", "DFmode", "||", "mode", "==", "TFmode", "||", "mode", "==", "IFmode", "||", "mode", "==", "KFmode", ")", "&&", "REG_P", "(", "SUBREG_REG", "(", "op", ")", ")", "&&", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "DImode", "||", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "TImode", "||", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "PTImode", "||", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "DDmode", "||", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "TDmode", ")", ")", "return", "true", ";", "}", "if", "(", "TARGET_SPE", "&&", "GET_CODE", "(", "op", ")", "==", "SUBREG", "&&", "mode", "==", "SImode", "&&", "REG_P", "(", "SUBREG_REG", "(", "op", ")", ")", "&&", "SPE_VECTOR_MODE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "OP", "is", "an", "invalid", "SUBREG", "operation", "on", "the", "e500", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "rtx", "force_offsettable", "(", "rtx", "addr", ",", "HOST_WIDE_INT", "size", ",", "bool", "reuse", ")", "{", "rtx", "base", "=", "addr", ";", "rtx", "offs", "=", "const0_rtx", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "{", "offs", "=", "XEXP", "(", "base", ",", "1", ")", ";", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "}", "if", "(", "!", "REG_P", "(", "base", ")", "||", "(", "REGNO", "(", "base", ")", "!=", "STACK_POINTER_REGNUM", "&&", "REGNO_PTR_FRAME_P", "(", "REGNO", "(", "base", ")", ")", ")", "||", "!", "CONST_INT_P", "(", "offs", ")", "||", "!", "SMALL_INT", "(", "INTVAL", "(", "offs", ")", ")", "||", "!", "SMALL_INT", "(", "INTVAL", "(", "offs", ")", "+", "size", ")", ")", "{", "if", "(", "reuse", ")", "emit_insn", "(", "gen_add2_insn", "(", "addr", ",", "offs", ")", ")", ";", "else", "addr", "=", "copy_to_mode_reg", "(", "Pmode", ",", "addr", ")", ";", "}", "return", "addr", ";", "}", "</s>" ]

[ "Helper", "function", "of", "arc_expand_movmem", ".", "ADDR", "points", "to", "a", "chunk", "of", "memory", ".", "Emit", "code", "and", "return", "an", "potentially", "modified", "address", "such", "that", "offsets", "up", "to", "SIZE", "are", "can", "be", "added", "to", "yield", "a", "legitimate", "address", ".", "if", "REUSE", "is", "set", ",", "ADDR", "is", "a", "register", "that", "may", "be", "modified", "." ]

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

[]

[ "<s>", "bool", "HexagonAsmParser", "::", "isLabel", "(", "AsmToken", "&", "Token", ")", "{", "MCAsmLexer", "&", "Lexer", "=", "getLexer", "(", ")", ";", "AsmToken", "const", "&", "Second", "=", "Lexer", ".", "getTok", "(", ")", ";", "AsmToken", "Third", "=", "Lexer", ".", "peekTok", "(", ")", ";", "StringRef", "String", "=", "Token", ".", "getString", "(", ")", ";", "if", "(", "Token", ".", "is", "(", "AsmToken", "::", "TokenKind", "::", "LCurly", ")", "||", "Token", ".", "is", "(", "AsmToken", "::", "TokenKind", "::", "RCurly", ")", ")", "return", "false", ";", "if", "(", "!", "Token", ".", "is", "(", "AsmToken", "::", "TokenKind", "::", "Identifier", ")", ")", "return", "true", ";", "if", "(", "!", "matchRegister", "(", "String", ".", "lower", "(", ")", ")", ")", "return", "true", ";", "(", "void", ")", "Second", ";", "assert", "(", "Second", ".", "is", "(", "AsmToken", "::", "Colon", ")", ")", ";", "StringRef", "Raw", "(", "String", ".", "data", "(", ")", ",", "Third", ".", "getString", "(", ")", ".", "data", "(", ")", "-", "String", ".", "data", "(", ")", "+", "Third", ".", "getString", "(", ")", ".", "size", "(", ")", ")", ";", "std", "::", "string", "Collapsed", "=", "Raw", ";", "Collapsed", ".", "erase", "(", "remove_if", "(", "Collapsed", ",", "isspace", ")", ",", "Collapsed", ".", "end", "(", ")", ")", ";", "StringRef", "Whole", "=", "Collapsed", ";", "std", "::", "pair", "<", "StringRef", ",", "StringRef", ">", "DotSplit", "=", "Whole", ".", "split", "(", "'.'", ")", ";", "if", "(", "!", "matchRegister", "(", "DotSplit", ".", "first", ".", "lower", "(", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "MachineInstr", "represents", "a", "label", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "SIInstrInfo", "::", "getSerializableDirectMachineOperandTargetFlags", "(", ")", "const", "{", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_GOTPCREL", ",", "\"amdgpu-gotprel\"", "}", ",", "{", "MO_GOTPCREL32_LO", ",", "\"amdgpu-gotprel32-lo\"", "}", ",", "{", "MO_GOTPCREL32_HI", ",", "\"amdgpu-gotprel32-hi\"", "}", ",", "{", "MO_REL32_LO", ",", "\"amdgpu-rel32-lo\"", "}", ",", "{", "MO_REL32_HI", ",", "\"amdgpu-rel32-hi\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "direct", "target", "flag", "values", "and", "their", "names", "." ]

[ "AMDGPU", "SI", "\"amdgpu-gotprel\"", "\"amdgpu-gotprel32-lo\"", "\"amdgpu-gotprel32-hi\"", "\"amdgpu-rel32-lo\"", "\"amdgpu-rel32-hi\"" ]

[]

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

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

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

[]

[ "<s>", "void", "GCNILPScheduler", "::", "releasePending", "(", ")", "{", "for", "(", "auto", "I", "=", "PendingQueue", ".", "begin", "(", ")", ",", "E", "=", "PendingQueue", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "auto", "&", "C", "=", "*", "I", "++", ";", "if", "(", "C", ".", "SU", "->", "getHeight", "(", ")", "<=", "CurCycle", ")", "{", "PendingQueue", ".", "remove", "(", "C", ")", ";", "AvailQueue", ".", "push_back", "(", "C", ")", ";", "C", ".", "SU", "->", "NodeQueueId", "=", "CurQueueId", "++", ";", "}", "}", "}", "</s>" ]

[ "Release", "pending", "ready", "nodes", "in", "to", "the", "available", "queue", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "machine_mode", "arc_preferred_simd_mode", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "HImode", ":", "return", "TARGET_PLUS_QMACW", "?", "V4HImode", ":", "V2HImode", ";", "case", "SImode", ":", "return", "V2SImode", ";", "default", ":", "return", "word_mode", ";", "}", "}", "</s>" ]

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

[ "arc" ]

[]

[ "<s>", "static", "bool", "pru_arg_in_reg_bysize", "(", "size_t", "sz", ")", "{", "return", "sz", "==", "1", "||", "sz", "==", "2", "||", "sz", "==", "3", "||", "sz", "==", "4", "||", "sz", "==", "8", ";", "}", "</s>" ]

[ "Check", "if", "argument", "with", "the", "given", "size", "must", "be", "passed/returned", "in", "a", "register", ".", "Reference", ":", "https", ":", "//e2e.ti.com/support/development_tools/compiler/f/343/p/650176/2393029", "Arguments", "other", "than", "8/16/24/32/64bits", "are", "passed", "on", "stack", "." ]

[ "pru", "1", "2", "3", "4", "8" ]

[]

[ "<s>", "bool", "mips_cannot_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "enum", "reg_class", "rclass", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "from", ")", "==", "8", "&&", "GET_MODE_SIZE", "(", "to", ")", "==", "8", "&&", "INTEGRAL_MODE_P", "(", "from", ")", "&&", "INTEGRAL_MODE_P", "(", "to", ")", ")", "return", "false", ";", "return", "reg_classes_intersect_p", "(", "FP_REGS", ",", "rclass", ")", ";", "}", "</s>" ]

[ "Implement", "CANNOT_CHANGE_MODE_CLASS", "." ]

[ "mips", "8", "8" ]

[]

[ "<s>", "static", "bool", "pa_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "size", "==", "UNITS_PER_WORD", "&&", "aligned_p", "&&", "function_label_operand", "(", "x", ",", "VOIDmode", ")", ")", "{", "fputs", "(", "size", "==", "8", "?", "\"\\t.dword\\tP%\"", ":", "\"\\t.word\\tP%\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "assembling", "integer", "objects", ".", "This", "code", "handles", "aligned", "SI", "and", "DI", "integers", "specially", ",", "since", "function", "references", "must", "be", "preceded", "by", "P", "%", "." ]

[ "pa", "8", "\"\\t.dword\\tP%\"", "\"\\t.word\\tP%\"" ]

[]

[ "<s>", "unsigned", "BlackfinRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameInfo", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "BF", "::", "FP", ":", "BF", "::", "SP", ";", "}", "</s>" ]

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

[ "Blackfin", "BF::FP", "BF::SP" ]

[]

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

[ "True", "if", "the", "machine", "scheduler", "should", "disable", "the", "TLI", "preference", "for", "preRA", "scheduling", "with", "the", "source", "level", "scheduler", "." ]

[ "Mips" ]

[]

[ "<s>", "void", "loongarch_init_builtins", "(", "void", ")", "{", "const", "struct", "loongarch_builtin_description", "*", "d", ";", "unsigned", "int", "i", ";", "tree", "type", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "loongarch_builtins", ")", ";", "i", "++", ")", "{", "d", "=", "&", "loongarch_builtins", "[", "i", "]", ";", "if", "(", "d", "->", "avail", "(", ")", ")", "{", "type", "=", "loongarch_build_function_type", "(", "d", "->", "function_type", ")", ";", "loongarch_builtin_decls", "[", "i", "]", "=", "add_builtin_function", "(", "d", "->", "name", ",", "type", ",", "i", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL", ")", ";", "loongarch_get_builtin_decl_index", "[", "d", "->", "icode", "]", "=", "i", ";", "}", "}", "}", "</s>" ]

[ "Implement", "TARGET_INIT_BUILTINS", "." ]

[ "loongarch", "0" ]

[]

[ "<s>", "static", "rtx", "ix86_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fntype_or_decl", ",", "bool", ")", "{", "machine_mode", "mode", ",", "orig_mode", ";", "orig_mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "mode", "=", "type_natural_mode", "(", "valtype", ",", "NULL", ",", "true", ")", ";", "return", "ix86_function_value_1", "(", "valtype", ",", "fntype_or_decl", ",", "orig_mode", ",", "mode", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "function", ".", "VALTYPE", "is", "the", "data", "type", "of", "the", "value", "(", "as", "a", "tree", ")", ".", "If", "the", "precise", "function", "being", "called", "is", "known", ",", "FUNC", "is", "its", "FUNCTION_DECL", ";", "otherwise", ",", "FUNC", "is", "0", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "free_state_stack", "(", "struct", "unw_reg_state", "*", "rs", ")", "{", "struct", "unw_reg_state", "*", "p", ",", "*", "next", ";", "for", "(", "p", "=", "rs", "->", "next", ";", "p", "!=", "NULL", ";", "p", "=", "next", ")", "{", "next", "=", "p", "->", "next", ";", "free_reg_state", "(", "p", ")", ";", "}", "rs", "->", "next", "=", "NULL", ";", "}", "</s>" ]

[ "Free", "all", "stacked", "register", "states", "(", "but", "not", "RS", "itself", ")", "." ]

[ "ia64" ]

[]

[ "<s>", "void", "pop_back", "(", ")", "{", "rbegin", "(", ")", "->", "second", ".", "pop_back", "(", ")", ";", "if", "(", "rbegin", "(", ")", "->", "second", ".", "empty", "(", ")", ")", "erase", "(", "rbegin", "(", ")", "->", "first", ")", ";", "}", "</s>" ]

[ "Pop", "one", "bit", "from", "the", "end", "of", "the", "vector", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "int", "X86FrameLowering", "::", "mergeSPUpdates", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "bool", "doMergeWithPrevious", ")", "const", "{", "if", "(", "(", "doMergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "begin", "(", ")", ")", "||", "(", "!", "doMergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", ")", "return", "0", ";", "MachineBasicBlock", "::", "iterator", "PI", "=", "doMergeWithPrevious", "?", "std", "::", "prev", "(", "MBBI", ")", ":", "MBBI", ";", "PI", "=", "skipDebugInstructionsBackward", "(", "PI", ",", "MBB", ".", "begin", "(", ")", ")", ";", "if", "(", "doMergeWithPrevious", "&&", "PI", "!=", "MBB", ".", "begin", "(", ")", "&&", "PI", "->", "isCFIInstruction", "(", ")", ")", "PI", "=", "std", "::", "prev", "(", "PI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "int", "Offset", "=", "0", ";", "if", "(", "(", "Opc", "==", "X86", "::", "ADD64ri32", "||", "Opc", "==", "X86", "::", "ADD64ri8", "||", "Opc", "==", "X86", "::", "ADD32ri", "||", "Opc", "==", "X86", "::", "ADD32ri8", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "assert", "(", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", ";", "Offset", "=", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "}", "else", "if", "(", "(", "Opc", "==", "X86", "::", "LEA32r", "||", "Opc", "==", "X86", "::", "LEA64_32r", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", "&&", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", "&&", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "1", "&&", "PI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", "==", "X86", "::", "NoRegister", "&&", "PI", "->", "getOperand", "(", "5", ")", ".", "getReg", "(", ")", "==", "X86", "::", "NoRegister", ")", "{", "Offset", "=", "PI", "->", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", ";", "}", "else", "if", "(", "(", "Opc", "==", "X86", "::", "SUB64ri32", "||", "Opc", "==", "X86", "::", "SUB64ri8", "||", "Opc", "==", "X86", "::", "SUB32ri", "||", "Opc", "==", "X86", "::", "SUB32ri8", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "assert", "(", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", ";", "Offset", "=", "-", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "}", "else", "return", "0", ";", "PI", "=", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "PI", "!=", "MBB", ".", "end", "(", ")", "&&", "PI", "->", "isCFIInstruction", "(", ")", ")", "{", "auto", "CIs", "=", "MBB", ".", "getParent", "(", ")", "->", "getFrameInstructions", "(", ")", ";", "MCCFIInstruction", "CI", "=", "CIs", "[", "PI", "->", "getOperand", "(", "0", ")", ".", "getCFIIndex", "(", ")", "]", ";", "if", "(", "CI", ".", "getOperation", "(", ")", "==", "MCCFIInstruction", "::", "OpDefCfaOffset", ")", "PI", "=", "MBB", ".", "erase", "(", "PI", ")", ";", "}", "if", "(", "!", "doMergeWithPrevious", ")", "MBBI", "=", "skipDebugInstructionsForward", "(", "PI", ",", "MBB", ".", "end", "(", ")", ")", ";", "return", "Offset", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "HexagonTargetObjectFile", "::", "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", ".", "isDataNoRel", "(", ")", "||", "Kind", ".", "isCommon", "(", ")", ")", "{", "Type", "*", "Ty", "=", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ";", "return", "IsInSmallSection", "(", "TM", ".", "getTargetData", "(", ")", "->", "getTypeAllocSize", "(", "Ty", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "void", "xstormy16_asm_out_destructor", "(", "rtx", "symbol", ",", "int", "priority", ")", "{", "const", "char", "*", "section", "=", "\".dtors\"", ";", "char", "buf", "[", "16", "]", ";", "if", "(", "priority", "!=", "DEFAULT_INIT_PRIORITY", ")", "{", "sprintf", "(", "buf", ",", "\".dtors.%.5u\"", ",", "MAX_INIT_PRIORITY", "-", "priority", ")", ";", "section", "=", "buf", ";", "}", "switch_to_section", "(", "get_section", "(", "section", ",", "0", ",", "NULL", ")", ")", ";", "assemble_align", "(", "POINTER_SIZE", ")", ";", "assemble_integer", "(", "symbol", ",", "POINTER_SIZE", "/", "BITS_PER_UNIT", ",", "POINTER_SIZE", ",", "1", ")", ";", "}", "</s>" ]

[ "Output", "constructors", "and", "destructors", ".", "Just", "like", "default_named_section_asm_out_", "*", "but", "do", "n't", "set", "the", "sections", "writable", "." ]

[ "stormy16", "\".dtors\"", "16", "\".dtors.%.5u\"", "0", "1" ]

[]

[ "<s>", "static", "section", "*", "avr_asm_select_section", "(", "tree", "decl", ",", "int", "reloc", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "section", "*", "sect", "=", "default_elf_select_section", "(", "decl", ",", "reloc", ",", "align", ")", ";", "if", "(", "decl", "&&", "DECL_P", "(", "decl", ")", "&&", "avr_progmem_p", "(", "decl", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", "{", "addr_space_t", "as", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", "as", "=", "ADDR_SPACE_FLASH", ";", "if", "(", "sect", "->", "common", ".", "flags", "&", "SECTION_NAMED", ")", "{", "const", "char", "*", "name", "=", "sect", "->", "named", ".", "name", ";", "const", "char", "*", "old_prefix", "=", "\".rodata\"", ";", "const", "char", "*", "new_prefix", "=", "avr_addrspace", "[", "as", "]", ".", "section_name", ";", "if", "(", "startswith", "(", "name", ",", "old_prefix", ")", ")", "{", "const", "char", "*", "sname", "=", "ACONCAT", "(", "(", "new_prefix", ",", "name", "+", "strlen", "(", "old_prefix", ")", ",", "NULL", ")", ")", ";", "return", "get_section", "(", "sname", ",", "sect", "->", "common", ".", "flags", "&", "~", "SECTION_DECLARED", ",", "sect", "->", "named", ".", "decl", ")", ";", "}", "}", "if", "(", "!", "progmem_section", "[", "as", "]", ")", "{", "progmem_section", "[", "as", "]", "=", "get_unnamed_section", "(", "0", ",", "avr_output_progmem_section_asm_op", ",", "avr_addrspace", "[", "as", "]", ".", "section_name", ")", ";", "}", "return", "progmem_section", "[", "as", "]", ";", "}", "return", "sect", ";", "}", "</s>" ]

[ "Implement", "`", "TARGET_ASM_SELECT_SECTION", "'" ]

[ "avr", "\".rodata\"", "0" ]

[]

[ "<s>", "bool", "AMDGPUPromoteAlloca", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "TM", ")", "return", "false", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", "F", ")", ";", "FunctionType", "*", "FTy", "=", "F", ".", "getFunctionType", "(", ")", ";", "LocalMemAvailable", "=", "ST", ".", "getLocalMemorySize", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "FTy", "->", "getNumParams", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Type", "*", "ParamTy", "=", "FTy", "->", "getParamType", "(", "i", ")", ";", "if", "(", "ParamTy", "->", "isPointerTy", "(", ")", "&&", "ParamTy", "->", "getPointerAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "{", "LocalMemAvailable", "=", "0", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Function has local memory argument. Promoting to \"", "\"local memory disabled.\\n\"", ")", ";", "break", ";", "}", "}", "if", "(", "LocalMemAvailable", ">", "0", ")", "{", "for", "(", "Module", "::", "global_iterator", "I", "=", "Mod", "->", "global_begin", "(", ")", ",", "E", "=", "Mod", "->", "global_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "GlobalVariable", "*", "GV", "=", "&", "*", "I", ";", "PointerType", "*", "GVTy", "=", "GV", "->", "getType", "(", ")", ";", "if", "(", "GVTy", "->", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "continue", ";", "for", "(", "Value", "::", "use_iterator", "U", "=", "GV", "->", "use_begin", "(", ")", ",", "UE", "=", "GV", "->", "use_end", "(", ")", ";", "U", "!=", "UE", ";", "++", "U", ")", "{", "Instruction", "*", "Use", "=", "dyn_cast", "<", "Instruction", ">", "(", "*", "U", ")", ";", "if", "(", "!", "Use", ")", "continue", ";", "if", "(", "Use", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "==", "&", "F", ")", "LocalMemAvailable", "-=", "Mod", "->", "getDataLayout", "(", ")", ".", "getTypeAllocSize", "(", "GVTy", "->", "getElementType", "(", ")", ")", ";", "}", "}", "}", "LocalMemAvailable", "=", "std", "::", "max", "(", "0", ",", "LocalMemAvailable", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "LocalMemAvailable", "<<", "\"bytes free in local memory.\\n\"", ")", ";", "visit", "(", "F", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "0", "AMDGPU", "0", "\"Function has local memory argument. Promoting to \"", "\"local memory disabled.\\n\"", "0", "AMDGPU", "0", "\"bytes free in local memory.\\n\"" ]

[]

[ "<s>", "void", "HexagonTTIImpl", "::", "getPeelingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "PeelingPreferences", "&", "PP", ")", "{", "BaseT", "::", "getPeelingPreferences", "(", "L", ",", "SE", ",", "PP", ")", ";", "if", "(", "L", "&&", "L", "->", "isInnermost", "(", ")", "&&", "canPeel", "(", "L", ")", "&&", "SE", ".", "getSmallConstantTripCount", "(", "L", ")", "==", "0", "&&", "SE", ".", "getSmallConstantMaxTripCount", "(", "L", ")", ">", "0", "&&", "SE", ".", "getSmallConstantMaxTripCount", "(", "L", ")", "<=", "5", ")", "{", "PP", ".", "PeelCount", "=", "2", ";", "}", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "peeling", "transformation", "." ]

[ "Hexagon", "Hexagon", "0", "0", "5", "2" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "SIRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "CallingConv", "::", "ID", "CC", "=", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "Cold", ":", "return", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "hasGFX90AInsts", "(", ")", "?", "CSR_AMDGPU_HighRegs_With_AGPRs_SaveList", ":", "CSR_AMDGPU_HighRegs_SaveList", ";", "case", "CallingConv", "::", "AMDGPU_Gfx", ":", "return", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "hasGFX90AInsts", "(", ")", "?", "CSR_AMDGPU_SI_Gfx_With_AGPRs_SaveList", ":", "CSR_AMDGPU_SI_Gfx_SaveList", ";", "default", ":", "{", "static", "const", "MCPhysReg", "NoCalleeSavedReg", "=", "AMDGPU", "::", "NoRegister", ";", "return", "&", "NoCalleeSavedReg", ";", "}", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU", "AMDGPU", "AMDGPU", "SI", "SI", "AMDGPU::NoRegister" ]

[]

[ "<s>", "void", "microblaze_expand_conditional_branch", "(", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "0", "]", ")", ";", "rtx", "cmp_op0", "=", "operands", "[", "1", "]", ";", "rtx", "cmp_op1", "=", "operands", "[", "2", "]", ";", "rtx", "label1", "=", "operands", "[", "3", "]", ";", "rtx", "comp_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "condition", ";", "gcc_assert", "(", "(", "GET_CODE", "(", "cmp_op0", ")", "==", "REG", ")", "||", "(", "GET_CODE", "(", "cmp_op0", ")", "==", "SUBREG", ")", ")", ";", "if", "(", "cmp_op1", "==", "const0_rtx", ")", "{", "comp_reg", "=", "cmp_op0", ";", "condition", "=", "gen_rtx_fmt_ee", "(", "signed_condition", "(", "code", ")", ",", "SImode", ",", "comp_reg", ",", "const0_rtx", ")", ";", "emit_jump_insn", "(", "gen_condjump", "(", "condition", ",", "label1", ")", ")", ";", "}", "else", "if", "(", "code", "==", "EQ", "||", "code", "==", "NE", ")", "{", "emit_insn", "(", "gen_xorsi3", "(", "comp_reg", ",", "cmp_op0", ",", "cmp_op1", ")", ")", ";", "condition", "=", "gen_rtx_fmt_ee", "(", "signed_condition", "(", "code", ")", ",", "SImode", ",", "comp_reg", ",", "const0_rtx", ")", ";", "emit_jump_insn", "(", "gen_condjump", "(", "condition", ",", "label1", ")", ")", ";", "}", "else", "{", "cmp_op1", "=", "force_reg", "(", "mode", ",", "cmp_op1", ")", ";", "condition", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "cmp_op0", ",", "cmp_op1", ")", ";", "emit_jump_insn", "(", "gen_branch_compare", "(", "condition", ",", "cmp_op0", ",", "cmp_op1", ",", "label1", ")", ")", ";", "}", "}", "</s>" ]

[ "Generate", "conditional", "branch", "--", "first", ",", "generate", "test", "condition", ",", "second", ",", "generate", "correct", "branch", "instruction", "." ]

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

[]

[ "<s>", "void", "WebAssemblyAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"EmitInstruction: \"", "<<", "*", "MI", "<<", "'\\n'", ")", ";", "assert", "(", "MI", "->", "getDesc", "(", ")", ".", "getNumDefs", "(", ")", "<=", "1", "&&", "\"Instructions with multiple result values not implemented\"", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "COPY", ":", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "OS", "<<", "\"\\t\"", "\"set_local \"", "<<", "regToString", "(", "MI", "->", "getOperand", "(", "0", ")", ")", "<<", "\", \"", "\"(get_local \"", "<<", "regToString", "(", "MI", "->", "getOperand", "(", "1", ")", ")", "<<", "\")\"", ";", "OutStreamer", "->", "EmitRawText", "(", "OS", ".", "str", "(", ")", ")", ";", "break", ";", "}", "case", "WebAssembly", "::", "ARGUMENT_I32", ":", "case", "WebAssembly", "::", "ARGUMENT_I64", ":", "case", "WebAssembly", "::", "ARGUMENT_F32", ":", "case", "WebAssembly", "::", "ARGUMENT_F64", ":", "break", ";", "default", ":", "{", "WebAssemblyMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"EmitInstruction: \"", "1", "\"Instructions with multiple result values not implemented\"", "128", "\"\\t\"", "\"set_local \"", "0", "\", \"", "\"(get_local \"", "1", "\")\"", "WebAssembly::ARGUMENT_I32", "WebAssembly::ARGUMENT_I64", "WebAssembly::ARGUMENT_F32", "WebAssembly::ARGUMENT_F64", "WebAssembly" ]

[]

[ "<s>", "void", "Cpu0MCCodeEmitter", "::", "EmitInstruction", "(", "uint64_t", "Val", ",", "unsigned", "Size", ",", "raw_ostream", "&", "OS", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Size", ";", "++", "i", ")", "{", "unsigned", "Shift", "=", "IsLittleEndian", "?", "i", "*", "8", ":", "(", "Size", "-", "1", "-", "i", ")", "*", "8", ";", "EmitByte", "(", "(", "Val", ">>", "Shift", ")", "&", "0xff", ",", "OS", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "loongarch_legitimize_move", "(", "machine_mode", "mode", ",", "rtx", "dest", ",", "rtx", "src", ")", "{", "if", "(", "!", "register_operand", "(", "dest", ",", "mode", ")", "&&", "!", "reg_or_0_operand", "(", "src", ",", "mode", ")", ")", "{", "loongarch_emit_move", "(", "dest", ",", "force_reg", "(", "mode", ",", "src", ")", ")", ";", "return", "true", ";", "}", "if", "(", "!", "register_operand", "(", "dest", ",", "mode", ")", "&&", "!", "register_operand", "(", "src", ",", "mode", ")", "&&", "!", "const_0_operand", "(", "src", ",", "mode", ")", ")", "{", "loongarch_emit_move", "(", "dest", ",", "force_reg", "(", "mode", ",", "src", ")", ")", ";", "return", "true", ";", "}", "if", "(", "CONSTANT_P", "(", "src", ")", "&&", "!", "move_operand", "(", "src", ",", "mode", ")", ")", "{", "loongarch_legitimize_const_move", "(", "mode", ",", "dest", ",", "src", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "copy_rtx", "(", "src", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "(", "set", "DEST", "SRC", ")", "is", "not", "a", "valid", "move", "instruction", ",", "emit", "an", "equivalent", "sequence", "that", "is", "valid", "." ]

[ "loongarch" ]

[]

[ "<s>", "static", "bool", "addr_generation_dependency_p", "(", "rtx", "dep_rtx", ",", "rtx_insn", "*", "insn", ")", "{", "rtx", "target", ",", "pat", ";", "if", "(", "NONJUMP_INSN_P", "(", "dep_rtx", ")", ")", "dep_rtx", "=", "PATTERN", "(", "dep_rtx", ")", ";", "if", "(", "GET_CODE", "(", "dep_rtx", ")", "==", "SET", ")", "{", "target", "=", "SET_DEST", "(", "dep_rtx", ")", ";", "if", "(", "GET_CODE", "(", "target", ")", "==", "STRICT_LOW_PART", ")", "target", "=", "XEXP", "(", "target", ",", "0", ")", ";", "while", "(", "GET_CODE", "(", "target", ")", "==", "SUBREG", ")", "target", "=", "SUBREG_REG", "(", "target", ")", ";", "if", "(", "GET_CODE", "(", "target", ")", "==", "REG", ")", "{", "int", "regno", "=", "REGNO", "(", "target", ")", ";", "if", "(", "s390_safe_attr_type", "(", "insn", ")", "==", "TYPE_LA", ")", "{", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "{", "gcc_assert", "(", "XVECLEN", "(", "pat", ",", "0", ")", "==", "2", ")", ";", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", ";", "return", "refers_to_regno_p", "(", "regno", ",", "SET_SRC", "(", "pat", ")", ")", ";", "}", "else", "if", "(", "get_attr_atype", "(", "insn", ")", "==", "ATYPE_AGEN", ")", "return", "reg_used_in_mem_p", "(", "regno", ",", "PATTERN", "(", "insn", ")", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "expression", "DEP_RTX", "sets", "an", "address", "register", "used", "by", "instruction", "INSN", "to", "address", "memory", "." ]

[ "s390", "0", "0", "2", "0", "0" ]

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "Mips32", ")", ",", "MipsABI", "(", "UnknownABI", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "IsLinux", "(", "true", ")", ",", "HasSEInReg", "(", "false", ")", ",", "HasCondMov", "(", "false", ")", ",", "HasMulDivAdd", "(", "false", ")", ",", "HasMinMax", "(", "false", ")", ",", "HasSwap", "(", "false", ")", ",", "HasBitCount", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"mips32\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "MipsABI", "==", "UnknownABI", ")", "MipsABI", "=", "hasMips64", "(", ")", "?", "N64", ":", "O32", ";", "assert", "(", "(", "(", "!", "hasMips64", "(", ")", "&&", "(", "isABI_O32", "(", ")", "||", "isABI_EABI", "(", ")", ")", ")", "||", "(", "hasMips64", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "\"Invalid Arch & ABI pair.\"", ")", ";", "if", "(", "TT", ".", "find", "(", "\"linux\"", ")", "==", "std", "::", "string", "::", "npos", ")", "IsLinux", "=", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"mips32\"", "Mips", "Mips", "Mips", "Mips", "Mips", "\"Invalid Arch & ABI pair.\"", "\"linux\"" ]

[]

[ "<s>", "static", "void", "alpha_sa_mask", "(", "unsigned", "long", "*", "imaskP", ",", "unsigned", "long", "*", "fmaskP", ")", "{", "unsigned", "long", "imask", "=", "0", ";", "unsigned", "long", "fmask", "=", "0", ";", "unsigned", "int", "i", ";", "if", "(", "cfun", "->", "is_thunk", ")", "{", "*", "imaskP", "=", "0", ";", "*", "fmaskP", "=", "0", ";", "return", ";", "}", "if", "(", "TARGET_ABI_OPEN_VMS", "&&", "alpha_procedure_type", "==", "PT_STACK", ")", "imask", "|=", "(", "1UL", "<<", "HARD_FRAME_POINTER_REGNUM", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "!", "fixed_regs", "[", "i", "]", "&&", "!", "call_used_regs", "[", "i", "]", "&&", "df_regs_ever_live_p", "(", "i", ")", "&&", "i", "!=", "REG_RA", ")", "{", "if", "(", "i", "<", "32", ")", "imask", "|=", "(", "1UL", "<<", "i", ")", ";", "else", "fmask", "|=", "(", "1UL", "<<", "(", "i", "-", "32", ")", ")", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "for", "(", "i", "=", "0", ";", ";", "++", "i", ")", "{", "unsigned", "regno", "=", "EH_RETURN_DATA_REGNO", "(", "i", ")", ";", "if", "(", "regno", "==", "INVALID_REGNUM", ")", "break", ";", "imask", "|=", "1UL", "<<", "regno", ";", "}", "}", "if", "(", "imask", "||", "fmask", "||", "alpha_ra_ever_killed", "(", ")", ")", "imask", "|=", "(", "1UL", "<<", "REG_RA", ")", ";", "*", "imaskP", "=", "imask", ";", "*", "fmaskP", "=", "fmask", ";", "}", "</s>" ]

[ "Compute", "register", "masks", "for", "saved", "registers", "." ]

[ "alpha", "0", "0", "0", "0", "1UL", "0", "32", "1UL", "1UL", "32", "0", "1UL", "1UL" ]

[]

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

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

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

[]

[ "<s>", "bool", "X86CallFrameOptimization", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TFL", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "!", "isLegal", "(", "MF", ")", ")", "return", "false", ";", "int", "FrameSetupOpcode", "=", "TII", "->", "getCallFrameSetupOpcode", "(", ")", ";", "bool", "Changed", "=", "false", ";", "ContextMap", "CallSeqMap", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "E", ";", "++", "BB", ")", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "BB", "->", "begin", "(", ")", ";", "I", "!=", "BB", "->", "end", "(", ")", ";", "++", "I", ")", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "FrameSetupOpcode", ")", "{", "CallContext", "&", "Context", "=", "CallSeqMap", "[", "I", "]", ";", "collectCallInfo", "(", "MF", ",", "*", "BB", ",", "I", ",", "Context", ")", ";", "}", "if", "(", "!", "isProfitable", "(", "MF", ",", "CallSeqMap", ")", ")", "return", "false", ";", "for", "(", "auto", "CC", ":", "CallSeqMap", ")", "if", "(", "CC", ".", "second", ".", "UsePush", ")", "Changed", "|=", "adjustCallSequence", "(", "MF", ",", "CC", ".", "first", ",", "CC", ".", "second", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "static", "bool", "arm_cannot_copy_insn_p", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "recog_memoized", "(", "insn", ")", "==", "CODE_FOR_tlscall", ")", "return", "true", ";", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "insn", ")", ",", "ALL", ")", "{", "const_rtx", "x", "=", "*", "iter", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_PIC_BASE", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_PIC_UNIFIED", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Must", "not", "copy", "any", "rtx", "that", "uses", "a", "pc-relative", "address", "." ]

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

[]

[ "<s>", "bool", "WebAssemblyLateEHPrepare", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Late EH Prepare **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "getExceptionHandlingType", "(", ")", "!=", "ExceptionHandling", "::", "Wasm", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasPersonalityFn", "(", ")", ")", "{", "Changed", "|=", "removeUnreachableEHPads", "(", "MF", ")", ";", "recordCatchRetBBs", "(", "MF", ")", ";", "Changed", "|=", "hoistCatches", "(", "MF", ")", ";", "Changed", "|=", "addCatchAlls", "(", "MF", ")", ";", "Changed", "|=", "replaceFuncletReturns", "(", "MF", ")", ";", "Changed", "|=", "ensureSingleBBTermPads", "(", "MF", ")", ";", "}", "Changed", "|=", "removeUnnecessaryUnreachables", "(", "MF", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasPersonalityFn", "(", ")", ")", "Changed", "|=", "restoreStackPointer", "(", "MF", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Late EH Prepare **********\\n\"", "\"********** Function: \"" ]

[]

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

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

[ "MSP430", "MSP430" ]

[]

[ "<s>", "bool", "shouldBuildLookupTablesForConstant", "(", "Constant", "*", "C", ")", "const", "{", "if", "(", "ST", "->", "isROPI", "(", ")", "||", "ST", "->", "isRWPI", "(", ")", "||", "ST", "->", "isPIP", "(", ")", ")", "return", "!", "C", "->", "needsRelocation", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "switches", "should", "be", "turned", "into", "lookup", "tables", "containing", "this", "constant", "value", "for", "the", "target", "." ]

[ "ARM" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "int", "ARMTTIImpl", "::", "getIntrinsicInstrCost", "(", "const", "IntrinsicCostAttributes", "&", "ICA", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "if", "(", "ST", "->", "hasMVEIntegerOps", "(", ")", "&&", "ICA", ".", "getID", "(", ")", "==", "Intrinsic", "::", "get_active_lane_mask", ")", "return", "0", ";", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ICA", ",", "CostKind", ")", ";", "}", "</s>" ]

[ "Get", "intrinsic", "cost", "based", "on", "arguments", "." ]

[ "ARM", "ARM", "Intrinsic::get_active_lane_mask", "0" ]

[]

[ "<s>", "bool", "PPCCTRLoopsVerify", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "if", "(", "!", "MDT", "->", "isReachableFromEntry", "(", "&", "MBB", ")", ")", "continue", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MII", "=", "MBB", ".", "getFirstTerminator", "(", ")", ",", "MIIE", "=", "MBB", ".", "end", "(", ")", ";", "MII", "!=", "MIIE", ";", "++", "MII", ")", "{", "unsigned", "Opc", "=", "MII", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "PPC", "::", "BDNZ8", "||", "Opc", "==", "PPC", "::", "BDNZ", "||", "Opc", "==", "PPC", "::", "BDZ8", "||", "Opc", "==", "PPC", "::", "BDZ", ")", "if", "(", "!", "verifyCTRBranch", "(", "&", "MBB", ",", "MII", ")", ")", "llvm_unreachable", "(", "\"Invalid PPC CTR loop!\"", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::BDNZ8", "PPC::BDNZ", "PPC::BDZ8", "PPC::BDZ", "\"Invalid PPC CTR loop!\"" ]

[]

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

[ "Enable", "matching", "of", "interleaved", "access", "groups", "." ]

[ "AArch64" ]

[]

[ "<s>", "static", "bool", "alpha_cannot_copy_insn_p", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "!", "reload_completed", "||", "!", "TARGET_EXPLICIT_RELOCS", ")", "return", "false", ";", "if", "(", "recog_memoized", "(", "insn", ")", ">=", "0", ")", "return", "get_attr_cannot_copy", "(", "insn", ")", ";", "else", "return", "false", ";", "}", "</s>" ]

[ "Indicate", "that", "INSN", "can", "not", "be", "duplicated", ".", "This", "is", "true", "for", "any", "insn", "that", "we", "'ve", "marked", "with", "gpdisp", "relocs", ",", "since", "those", "have", "to", "stay", "in", "1-1", "correspondence", "with", "one", "another", ".", "Technically", "we", "could", "copy", "them", "if", "we", "could", "set", "up", "a", "mapping", "from", "one", "sequence", "number", "to", "another", ",", "across", "the", "set", "of", "insns", "to", "be", "duplicated", ".", "This", "seems", "overly", "complicated", "and", "error-prone", "since", "interblock", "motion", "from", "sched-ebb", "could", "move", "one", "of", "the", "pair", "of", "insns", "to", "a", "different", "block", ".", "Also", "can", "not", "allow", "jsr", "insns", "to", "be", "duplicated", ".", "If", "they", "throw", "exceptions", ",", "then", "they", "'ll", "be", "in", "a", "different", "block", "from", "their", "ldgp", ".", "Which", "could", "lead", "the", "bb", "reorder", "code", "to", "think", "that", "it", "would", "be", "ok", "to", "copy", "just", "the", "block", "containing", "the", "call", "and", "branch", "to", "the", "block", "containing", "the", "ldgp", "." ]

[ "alpha", "0" ]

[]

[ "<s>", "bool", "pass_vsetvl", "::", "can_refine_vsetvl_p", "(", "const", "basic_block", "cfg_bb", ",", "const", "vector_insn_info", "&", "info", ")", "const", "{", "if", "(", "!", "m_vector_manager", "->", "all_same_ratio_p", "(", "m_vector_manager", "->", "vector_avin", "[", "cfg_bb", "->", "index", "]", ")", ")", "return", "false", ";", "if", "(", "!", "m_vector_manager", "->", "all_same_avl_p", "(", "cfg_bb", ",", "m_vector_manager", "->", "vector_avin", "[", "cfg_bb", "->", "index", "]", ")", ")", "return", "false", ";", "size_t", "expr_id", "=", "bitmap_first_set_bit", "(", "m_vector_manager", "->", "vector_avin", "[", "cfg_bb", "->", "index", "]", ")", ";", "if", "(", "!", "m_vector_manager", "->", "vector_exprs", "[", "expr_id", "]", "->", "same_vlmax_p", "(", "info", ")", ")", "return", "false", ";", "if", "(", "!", "m_vector_manager", "->", "vector_exprs", "[", "expr_id", "]", "->", "compatible_avl_p", "(", "info", ")", ")", "return", "false", ";", "edge", "e", ";", "edge_iterator", "ei", ";", "bool", "all_valid_p", "=", "true", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "cfg_bb", "->", "preds", ")", "{", "if", "(", "bitmap_empty_p", "(", "m_vector_manager", "->", "vector_avout", "[", "e", "->", "src", "->", "index", "]", ")", ")", "{", "all_valid_p", "=", "false", ";", "break", ";", "}", "}", "if", "(", "!", "all_valid_p", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "VSETVL", "in", "the", "block", "can", "be", "refined", "as", "vsetvl", "zero", ",", "zero", "." ]

[ "riscv" ]

[]

[ "<s>", "XCoreTargetMachine", "::", "XCoreTargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "DL", "(", "\"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32-f64:32-a:0:32-n32\"", ")", ",", "InstrInfo", "(", ")", ",", "FrameLowering", "(", "Subtarget", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "TSInfo", "(", "*", "this", ")", "{", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "ILP32", "architecture", "model", "." ]

[ "XCore", "XCore", "XCore", "\"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32-f64:32-a:0:32-n32\"" ]

[]

[ "<s>", "bool", "s390_contiguous_bitmask_p", "(", "unsigned", "HOST_WIDE_INT", "in", ",", "int", "size", ",", "int", "*", "pos", ",", "int", "*", "length", ")", "{", "int", "tmp_pos", "=", "0", ";", "int", "tmp_length", "=", "0", ";", "int", "i", ";", "unsigned", "HOST_WIDE_INT", "mask", "=", "1ULL", ";", "bool", "contiguous", "=", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "size", ";", "mask", "<<=", "1", ",", "i", "++", ")", "{", "if", "(", "contiguous", ")", "{", "if", "(", "mask", "&", "in", ")", "tmp_length", "++", ";", "else", "break", ";", "}", "else", "{", "if", "(", "mask", "&", "in", ")", "{", "contiguous", "=", "true", ";", "tmp_length", "++", ";", "}", "else", "tmp_pos", "++", ";", "}", "}", "if", "(", "!", "tmp_length", ")", "return", "false", ";", "mask", "=", "(", "-", "1LL", "&", "~", "(", "(", "(", "1ULL", "<<", "(", "tmp_length", "+", "tmp_pos", "-", "1", ")", ")", "<<", "1", ")", "-", "1", ")", ")", ";", "if", "(", "mask", "&", "in", ")", "return", "false", ";", "if", "(", "tmp_length", "+", "tmp_pos", "-", "1", ">", "size", ")", "return", "false", ";", "if", "(", "length", ")", "*", "length", "=", "tmp_length", ";", "if", "(", "pos", ")", "*", "pos", "=", "tmp_pos", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "IN", "contains", "a", "contiguous", "bitfield", "in", "the", "lower", "SIZE", "bits", "and", "no", "other", "bits", "are", "set", "in", "IN", ".", "POS", "and", "LENGTH", "can", "be", "used", "to", "obtain", "the", "start", "position", "and", "the", "length", "of", "the", "bitfield", ".", "POS", "gives", "the", "position", "of", "the", "first", "bit", "of", "the", "bitfield", "counting", "from", "the", "lowest", "order", "bit", "starting", "with", "zero", ".", "In", "order", "to", "use", "this", "value", "for", "S/390", "instructions", "this", "has", "to", "be", "converted", "to", "``", "bits", "big", "endian", "''", "style", "." ]

[ "s390", "0", "0", "1ULL", "0", "1", "1LL", "1ULL", "1", "1", "1", "1" ]

[]

[ "<s>", "void", "Z80InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DestReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "SrcSize", ",", "DstSize", ";", "SrcSize", "=", "getRegSize", "(", "SrcReg", ")", ";", "DstSize", "=", "getRegSize", "(", "DestReg", ")", ";", "assert", "(", "DstSize", ">=", "SrcSize", "&&", "\"Destination is smaller than source can't copy\"", ")", ";", "if", "(", "DstSize", "==", "8", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Z80", "::", "LD8rr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "}", "else", "{", "if", "(", "SrcSize", "==", "16", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Z80", "::", "LD8rr", ")", ",", "getPairHigh", "(", "DestReg", ")", ")", ".", "addReg", "(", "getPairHigh", "(", "SrcReg", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Z80", "::", "LD8rr", ")", ",", "getPairLow", "(", "DestReg", ")", ")", ".", "addReg", "(", "getPairLow", "(", "SrcReg", ")", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Z80", "::", "LD8ri", ")", ",", "getPairHigh", "(", "DestReg", ")", ")", ".", "addImm", "(", "0", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Z80", "::", "LD8rr", ")", ",", "getPairLow", "(", "DestReg", ")", ")", ".", "addReg", "(", "SrcReg", ")", ";", "}", "}", "}", "</s>" ]

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

[ "Z80", "Z80", "\"Destination is smaller than source can't copy\"", "8", "Z80::LD8rr", "16", "Z80::LD8rr", "Z80::LD8rr", "Z80::LD8ri", "0", "Z80::LD8rr" ]

[]

[ "<s>", "static", "int", "rs6000_memory_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "rclass", ",", "bool", "in", "ATTRIBUTE_UNUSED", ")", "{", "int", "ret", ";", "if", "(", "TARGET_DEBUG_COST", ")", "dbg_cost_ctrl", "++", ";", "if", "(", "reg_classes_intersect_p", "(", "rclass", ",", "GENERAL_REGS", ")", ")", "ret", "=", "4", "*", "hard_regno_nregs", "[", "0", "]", "[", "mode", "]", ";", "else", "if", "(", "(", "reg_classes_intersect_p", "(", "rclass", ",", "FLOAT_REGS", ")", "||", "reg_classes_intersect_p", "(", "rclass", ",", "VSX_REGS", ")", ")", ")", "ret", "=", "4", "*", "hard_regno_nregs", "[", "32", "]", "[", "mode", "]", ";", "else", "if", "(", "reg_classes_intersect_p", "(", "rclass", ",", "ALTIVEC_REGS", ")", ")", "ret", "=", "4", "*", "hard_regno_nregs", "[", "FIRST_ALTIVEC_REGNO", "]", "[", "mode", "]", ";", "else", "ret", "=", "4", "+", "rs6000_register_move_cost", "(", "mode", ",", "rclass", ",", "GENERAL_REGS", ")", ";", "if", "(", "TARGET_DEBUG_COST", ")", "{", "if", "(", "dbg_cost_ctrl", "==", "1", ")", "fprintf", "(", "stderr", ",", "\"rs6000_memory_move_cost: ret=%d, mode=%s, rclass=%s, in=%d\\n\"", ",", "ret", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "reg_class_names", "[", "rclass", "]", ",", "in", ")", ";", "dbg_cost_ctrl", "--", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "A", "C", "expressions", "returning", "the", "cost", "of", "moving", "data", "of", "MODE", "from", "a", "register", "to", "or", "from", "memory", "." ]

[ "rs6000", "4", "0", "4", "32", "4", "4", "1", "\"rs6000_memory_move_cost: ret=%d, mode=%s, rclass=%s, in=%d\\n\"" ]

[]

[ "<s>", "bool", "ARCFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "MutableArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Restore callee saved registers: \"", "<<", "MBB", ".", "getParent", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "unsigned", "Last", "=", "determineLastCalleeSave", "(", "CSI", ")", ";", "if", "(", "UseSaveRestoreFunclet", "&&", "Last", ">", "ARC", "::", "R14", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</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", "(", ")", "." ]

[ "ARC", "ARC", "\"Restore callee saved registers: \"", "\"\\n\"", "ARC::R14" ]

[]

[ "<s>", "static", "bool", "ix86_nopic_noplt_attribute_p", "(", "rtx", "call_op", ")", "{", "if", "(", "flag_pic", "||", "ix86_cmodel", "==", "CM_LARGE", "||", "!", "(", "TARGET_64BIT", "||", "HAVE_AS_IX86_GOT32X", ")", "||", "TARGET_MACHO", "||", "TARGET_SEH", "||", "TARGET_PECOFF", "||", "SYMBOL_REF_LOCAL_P", "(", "call_op", ")", ")", "return", "false", ";", "tree", "symbol_decl", "=", "SYMBOL_REF_DECL", "(", "call_op", ")", ";", "if", "(", "!", "flag_plt", "||", "(", "symbol_decl", "!=", "NULL_TREE", "&&", "lookup_attribute", "(", "\"noplt\"", ",", "DECL_ATTRIBUTES", "(", "symbol_decl", ")", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "function", "being", "called", "was", "marked", "with", "attribute", "``", "noplt", "''", "or", "using", "-fno-plt", "and", "we", "are", "compiling", "for", "non-PIC", "and", "x86_64", ".", "We", "need", "to", "handle", "the", "non-PIC", "case", "in", "the", "backend", "because", "there", "is", "no", "easy", "interface", "for", "the", "front-end", "to", "force", "non-PLT", "calls", "to", "use", "the", "GOT", ".", "This", "is", "currently", "used", "only", "with", "64-bit", "ELF", "targets", "to", "call", "the", "function", "marked", "``", "noplt", "''", "indirectly", "." ]

[ "i386", "\"noplt\"" ]

[]

[ "<s>", "static", "void", "rs6000_sched_finish", "(", "FILE", "*", "dump", ",", "int", "sched_verbose", ")", "{", "int", "n_groups", ";", "if", "(", "sched_verbose", ")", "fprintf", "(", "dump", ",", "\"=== Finishing schedule.\\n\"", ")", ";", "if", "(", "reload_completed", "&&", "rs6000_sched_groups", ")", "{", "if", "(", "sel_sched_p", "(", ")", ")", "return", ";", "if", "(", "rs6000_sched_insert_nops", "==", "sched_finish_none", ")", "return", ";", "if", "(", "rs6000_sched_insert_nops", "==", "sched_finish_pad_groups", ")", "n_groups", "=", "pad_groups", "(", "dump", ",", "sched_verbose", ",", "current_sched_info", "->", "prev_head", ",", "current_sched_info", "->", "next_tail", ")", ";", "else", "n_groups", "=", "redefine_groups", "(", "dump", ",", "sched_verbose", ",", "current_sched_info", "->", "prev_head", ",", "current_sched_info", "->", "next_tail", ")", ";", "if", "(", "sched_verbose", ">=", "6", ")", "{", "fprintf", "(", "dump", ",", "\"ngroups = %d\\n\"", ",", "n_groups", ")", ";", "print_rtl", "(", "dump", ",", "current_sched_info", "->", "prev_head", ")", ";", "fprintf", "(", "dump", ",", "\"Done finish_sched\\n\"", ")", ";", "}", "}", "}", "</s>" ]

[ "The", "following", "function", "is", "called", "at", "the", "end", "of", "scheduling", "BB", ".", "After", "reload", ",", "it", "inserts", "nops", "at", "insn", "group", "bundling", "." ]

[ "powerpcspe", "\"=== Finishing schedule.\\n\"", "6", "\"ngroups = %d\\n\"", "\"Done finish_sched\\n\"" ]

[]

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

[ "Patmos", "Patmos" ]

[]

[ "<s>", "void", "AArch64Operand", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "k_FPImm", ":", "OS", "<<", "\"<fpimm \"", "<<", "getFPImm", "(", ")", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", ";", "if", "(", "!", "getFPImmIsExact", "(", ")", ")", "OS", "<<", "\" (inexact)\"", ";", "OS", "<<", "\">\"", ";", "break", ";", "case", "k_Barrier", ":", "{", "StringRef", "Name", "=", "getBarrierName", "(", ")", ";", "if", "(", "!", "Name", ".", "empty", "(", ")", ")", "OS", "<<", "\"<barrier \"", "<<", "Name", "<<", "\">\"", ";", "else", "OS", "<<", "\"<barrier invalid #\"", "<<", "getBarrier", "(", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_Immediate", ":", "OS", "<<", "*", "getImm", "(", ")", ";", "break", ";", "case", "k_ShiftedImm", ":", "{", "unsigned", "Shift", "=", "getShiftedImmShift", "(", ")", ";", "OS", "<<", "\"<shiftedimm \"", ";", "OS", "<<", "*", "getShiftedImmVal", "(", ")", ";", "OS", "<<", "\", lsl #\"", "<<", "AArch64_AM", "::", "getShiftValue", "(", "Shift", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_CondCode", ":", "OS", "<<", "\"<condcode \"", "<<", "getCondCode", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "k_VectorList", ":", "{", "OS", "<<", "\"<vectorlist \"", ";", "unsigned", "Reg", "=", "getVectorListStart", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "getVectorListCount", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "OS", "<<", "Reg", "+", "i", "<<", "\" \"", ";", "OS", "<<", "\">\"", ";", "break", ";", "}", "case", "k_VectorIndex", ":", "OS", "<<", "\"<vectorindex \"", "<<", "getVectorIndex", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "k_SysReg", ":", "OS", "<<", "\"<sysreg: \"", "<<", "getSysReg", "(", ")", "<<", "'>'", ";", "break", ";", "case", "k_Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "case", "k_SysCR", ":", "OS", "<<", "\"c\"", "<<", "getSysCR", "(", ")", ";", "break", ";", "case", "k_Prefetch", ":", "{", "StringRef", "Name", "=", "getPrefetchName", "(", ")", ";", "if", "(", "!", "Name", ".", "empty", "(", ")", ")", "OS", "<<", "\"<prfop \"", "<<", "Name", "<<", "\">\"", ";", "else", "OS", "<<", "\"<prfop invalid #\"", "<<", "getPrefetch", "(", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_PSBHint", ":", "OS", "<<", "getPSBHintName", "(", ")", ";", "break", ";", "case", "k_BTIHint", ":", "OS", "<<", "getBTIHintName", "(", ")", ";", "break", ";", "case", "k_MatrixRegister", ":", "OS", "<<", "\"<matrix \"", "<<", "getMatrixReg", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "k_MatrixTileList", ":", "{", "OS", "<<", "\"<matrixlist \"", ";", "unsigned", "RegMask", "=", "getMatrixTileListRegMask", "(", ")", ";", "unsigned", "MaxBits", "=", "8", ";", "for", "(", "unsigned", "I", "=", "MaxBits", ";", "I", ">", "0", ";", "--", "I", ")", "OS", "<<", "(", "(", "RegMask", "&", "(", "1", "<<", "(", "I", "-", "1", ")", ")", ")", ">>", "(", "I", "-", "1", ")", ")", ";", "OS", "<<", "'>'", ";", "break", ";", "}", "case", "k_SVCR", ":", "{", "OS", "<<", "getSVCR", "(", ")", ";", "break", ";", "}", "case", "k_Register", ":", "OS", "<<", "\"<register \"", "<<", "getReg", "(", ")", "<<", "\">\"", ";", "if", "(", "!", "getShiftExtendAmount", "(", ")", "&&", "!", "hasShiftExtendAmount", "(", ")", ")", "break", ";", "LLVM_FALLTHROUGH", ";", "case", "k_ShiftExtend", ":", "OS", "<<", "\"<\"", "<<", "AArch64_AM", "::", "getShiftExtendName", "(", "getShiftExtendType", "(", ")", ")", "<<", "\" #\"", "<<", "getShiftExtendAmount", "(", ")", ";", "if", "(", "!", "hasShiftExtendAmount", "(", ")", ")", "OS", "<<", "\"<imp>\"", ";", "OS", "<<", "'>'", ";", "break", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"<fpimm \"", "\" (inexact)\"", "\">\"", "\"<barrier \"", "\">\"", "\"<barrier invalid #\"", "\">\"", "\"<shiftedimm \"", "\", lsl #\"", "AArch64_AM::getShiftValue", "\">\"", "\"<condcode \"", "\">\"", "\"<vectorlist \"", "0", "\" \"", "\">\"", "\"<vectorindex \"", "\">\"", "\"<sysreg: \"", "\"'\"", "\"'\"", "\"c\"", "\"<prfop \"", "\">\"", "\"<prfop invalid #\"", "\">\"", "\"<matrix \"", "\">\"", "\"<matrixlist \"", "8", "0", "1", "1", "1", "\"<register \"", "\">\"", "\"<\"", "AArch64_AM::getShiftExtendName", "\" #\"", "\"<imp>\"" ]

[]

[ "<s>", "unsigned", "AVRMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "APFloat", "(", "MO", ".", "getFPImm", "(", ")", ")", ".", "bitcastToAPInt", "(", ")", ".", "getHiBits", "(", "32", ")", ".", "getLimitedValue", "(", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "return", "getExprOpValue", "(", "MO", ".", "getExpr", "(", ")", ",", "Fixups", ",", "STI", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "HexagonOptimizeSZextends", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "unsigned", "Idx", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "F", ".", "getAttributes", "(", ")", ".", "hasParamAttr", "(", "Idx", ",", "Attribute", "::", "SExt", ")", ")", "{", "if", "(", "!", "isa", "<", "PointerType", ">", "(", "Arg", ".", "getType", "(", ")", ")", ")", "{", "for", "(", "auto", "UI", "=", "Arg", ".", "use_begin", "(", ")", ";", "UI", "!=", "Arg", ".", "use_end", "(", ")", ";", ")", "{", "if", "(", "isa", "<", "SExtInst", ">", "(", "*", "UI", ")", ")", "{", "Instruction", "*", "Use", "=", "cast", "<", "Instruction", ">", "(", "*", "UI", ")", ";", "SExtInst", "*", "SI", "=", "new", "SExtInst", "(", "&", "Arg", ",", "Use", "->", "getType", "(", ")", ")", ";", "assert", "(", "EVT", "::", "getEVT", "(", "SI", "->", "getType", "(", ")", ")", "==", "(", "EVT", "::", "getEVT", "(", "Use", "->", "getType", "(", ")", ")", ")", ")", ";", "++", "UI", ";", "Use", "->", "replaceAllUsesWith", "(", "SI", ")", ";", "Instruction", "*", "First", "=", "&", "F", ".", "getEntryBlock", "(", ")", ".", "front", "(", ")", ";", "SI", "->", "insertBefore", "(", "First", ")", ";", "Use", "->", "eraseFromParent", "(", ")", ";", "}", "else", "{", "++", "UI", ";", "}", "}", "}", "}", "++", "Idx", ";", "}", "for", "(", "auto", "&", "B", ":", "F", ")", "{", "for", "(", "auto", "&", "I", ":", "B", ")", "{", "BinaryOperator", "*", "Ashr", "=", "dyn_cast", "<", "BinaryOperator", ">", "(", "&", "I", ")", ";", "if", "(", "!", "(", "Ashr", "&&", "Ashr", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "AShr", ")", ")", "continue", ";", "Value", "*", "AshrOp1", "=", "Ashr", "->", "getOperand", "(", "1", ")", ";", "ConstantInt", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "AshrOp1", ")", ";", "if", "(", "!", "(", "C", "&&", "C", "->", "getSExtValue", "(", ")", "==", "16", ")", ")", "continue", ";", "Instruction", "*", "Shl", "=", "dyn_cast", "<", "Instruction", ">", "(", "Ashr", "->", "getOperand", "(", "0", ")", ")", ";", "if", "(", "!", "(", "Shl", "&&", "Shl", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "Shl", ")", ")", "continue", ";", "Value", "*", "Intr", "=", "Shl", "->", "getOperand", "(", "0", ")", ";", "Value", "*", "ShlOp1", "=", "Shl", "->", "getOperand", "(", "1", ")", ";", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "ShlOp1", ")", ";", "if", "(", "!", "(", "C", "&&", "C", "->", "getSExtValue", "(", ")", "==", "16", ")", ")", "continue", ";", "if", "(", "IntrinsicInst", "*", "I", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "Intr", ")", ")", "{", "if", "(", "!", "intrinsicAlreadySextended", "(", "I", "->", "getIntrinsicID", "(", ")", ")", ")", "continue", ";", "for", "(", "auto", "UI", "=", "Ashr", "->", "user_begin", "(", ")", ",", "UE", "=", "Ashr", "->", "user_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "const", "Use", "&", "TheUse", "=", "UI", ".", "getUse", "(", ")", ";", "if", "(", "Instruction", "*", "J", "=", "dyn_cast", "<", "Instruction", ">", "(", "TheUse", ".", "getUser", "(", ")", ")", ")", "{", "J", "->", "replaceUsesOfWith", "(", "Ashr", ",", "I", ")", ";", "}", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

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

[]

[ "<s>", "void", "MipsELFStreamer", "::", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "bool", ")", "{", "MCELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "MCContext", "&", "Context", "=", "getContext", "(", ")", ";", "const", "MCRegisterInfo", "*", "MCRegInfo", "=", "Context", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "unsigned", "OpIndex", "=", "0", ";", "OpIndex", "<", "Inst", ".", "getNumOperands", "(", ")", ";", "++", "OpIndex", ")", "{", "const", "MCOperand", "&", "Op", "=", "Inst", ".", "getOperand", "(", "OpIndex", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "RegInfoRecord", "->", "SetPhysRegUsed", "(", "Reg", ",", "MCRegInfo", ")", ";", "}", "createPendingLabelRelocs", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "save_restore_insns", "(", "int", "store_p", ")", "{", "long", "mask", "=", "cfun", "->", "machine", "->", "mask", ";", "int", "regno", ";", "rtx", "base_reg_rtx", ";", "HOST_WIDE_INT", "base_offset", ";", "HOST_WIDE_INT", "gp_offset", ";", "HOST_WIDE_INT", "end_offset", ";", "gcc_assert", "(", "!", "frame_pointer_needed", "||", "BITSET_P", "(", "mask", ",", "HARD_FRAME_POINTER_REGNUM", "-", "GP_REG_FIRST", ")", ")", ";", "if", "(", "mask", "==", "0", ")", "{", "base_reg_rtx", "=", "0", ",", "base_offset", "=", "0", ";", "return", ";", "}", "gp_offset", "=", "cfun", "->", "machine", "->", "gp_sp_offset", ";", "end_offset", "=", "gp_offset", "-", "(", "cfun", "->", "machine", "->", "gp_reg_size", "-", "GET_MODE_SIZE", "(", "gpr_mode", ")", ")", ";", "if", "(", "gp_offset", "<", "0", "||", "end_offset", "<", "0", ")", "internal_error", "(", "\"%<gp_offset%> (%ld) or %<end_offset%> (%ld) is less than zero\"", ",", "(", "long", ")", "gp_offset", ",", "(", "long", ")", "end_offset", ")", ";", "else", "if", "(", "gp_offset", "<", "32768", ")", "base_reg_rtx", "=", "stack_pointer_rtx", ",", "base_offset", "=", "0", ";", "else", "{", "int", "regno", ";", "int", "reg_save_count", "=", "0", ";", "for", "(", "regno", "=", "GP_REG_LAST", ";", "regno", ">=", "GP_REG_FIRST", ";", "regno", "--", ")", "if", "(", "BITSET_P", "(", "mask", ",", "regno", "-", "GP_REG_FIRST", ")", ")", "reg_save_count", "+=", "1", ";", "base_offset", "=", "gp_offset", "-", "(", "(", "reg_save_count", "-", "1", ")", "*", "4", ")", ";", "base_reg_rtx", "=", "iq2000_add_large_offset_to_sp", "(", "base_offset", ")", ";", "}", "for", "(", "regno", "=", "GP_REG_LAST", ";", "regno", ">=", "GP_REG_FIRST", ";", "regno", "--", ")", "{", "if", "(", "BITSET_P", "(", "mask", ",", "regno", "-", "GP_REG_FIRST", ")", ")", "{", "rtx", "reg_rtx", ";", "rtx", "mem_rtx", "=", "gen_rtx_MEM", "(", "gpr_mode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "base_reg_rtx", ",", "GEN_INT", "(", "gp_offset", "-", "base_offset", ")", ")", ")", ";", "reg_rtx", "=", "gen_rtx_REG", "(", "gpr_mode", ",", "regno", ")", ";", "if", "(", "store_p", ")", "iq2000_emit_frame_related_store", "(", "mem_rtx", ",", "reg_rtx", ",", "gp_offset", ")", ";", "else", "{", "emit_move_insn", "(", "reg_rtx", ",", "mem_rtx", ")", ";", "}", "gp_offset", "-=", "GET_MODE_SIZE", "(", "gpr_mode", ")", ";", "}", "}", "}", "</s>" ]

[ "Save", "or", "restore", "instructions", "based", "on", "whether", "this", "is", "the", "prologue", "or", "epilogue", ".", "prologue", "is", "1", "for", "the", "prologue", "." ]

[ "iq2000", "0", "0", "0", "0", "0", "\"%<gp_offset%> (%ld) or %<end_offset%> (%ld) is less than zero\"", "32768", "0", "0", "1", "1", "4" ]

[]

[ "<s>", "MachineInstr", "*", "SystemZInstrInfo", "::", "commuteInstructionImpl", "(", "MachineInstr", "&", "MI", ",", "bool", "NewMI", ",", "unsigned", "OpIdx1", ",", "unsigned", "OpIdx2", ")", "const", "{", "auto", "cloneIfNew", "=", "[", "NewMI", "]", "(", "MachineInstr", "&", "MI", ")", "->", "MachineInstr", "&", "{", "if", "(", "NewMI", ")", "return", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "CloneMachineInstr", "(", "&", "MI", ")", ";", "return", "MI", ";", "}", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "SystemZ", "::", "LOCRMux", ":", "case", "SystemZ", "::", "LOCFHR", ":", "case", "SystemZ", "::", "LOCR", ":", "case", "SystemZ", "::", "LOCGR", ":", "{", "auto", "&", "WorkingMI", "=", "cloneIfNew", "(", "MI", ")", ";", "unsigned", "CCValid", "=", "WorkingMI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "unsigned", "CCMask", "=", "WorkingMI", ".", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", ";", "WorkingMI", ".", "getOperand", "(", "4", ")", ".", "setImm", "(", "CCMask", "^", "CCValid", ")", ";", "return", "TargetInstrInfo", "::", "commuteInstructionImpl", "(", "WorkingMI", ",", "false", ",", "OpIdx1", ",", "OpIdx2", ")", ";", "}", "default", ":", "return", "TargetInstrInfo", "::", "commuteInstructionImpl", "(", "MI", ",", "NewMI", ",", "OpIdx1", ",", "OpIdx2", ")", ";", "}", "}", "</s>" ]

[ "Commutes", "the", "operands", "in", "the", "given", "instruction", "by", "changing", "the", "operands", "order", "and/or", "changing", "the", "instruction", "'s", "opcode", "and/or", "the", "immediate", "value", "operand", "." ]

[ "SystemZ", "SystemZ", "SystemZ::LOCRMux", "SystemZ::LOCFHR", "SystemZ::LOCR", "SystemZ::LOCGR", "3", "4", "4" ]

[]

[ "<s>", "unsigned", "getCacheLineSize", "(", ")", "const", "override", "{", "return", "256", ";", "}", "</s>" ]

[ "Return", "the", "target", "cache", "line", "size", "in", "bytes", "." ]

[ "SystemZ", "256" ]

[]

[ "<s>", "tree", "ix86_builtin_decl", "(", "unsigned", "code", ",", "bool", ")", "{", "if", "(", "code", ">=", "IX86_BUILTIN_MAX", ")", "return", "error_mark_node", ";", "return", "ix86_builtins", "[", "code", "]", ";", "}", "</s>" ]

[ "Return", "the", "ix86", "builtin", "for", "CODE", "." ]

[ "i386" ]

[]

[ "<s>", "void", "AVRDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "if", "(", "trySelect", "(", "N", ")", ")", "return", ";", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "1" ]

[]

[ "<s>", "void", "MINA32FrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "}", "</s>" ]

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

[ "MINA32", "MINA32" ]

[]

[ "<s>", "void", "NVPTXPassConfig", "::", "addIRPasses", "(", ")", "{", "disablePass", "(", "&", "PrologEpilogCodeInserterID", ")", ";", "disablePass", "(", "&", "MachineCopyPropagationID", ")", ";", "disablePass", "(", "&", "TailDuplicateID", ")", ";", "addPass", "(", "createNVPTXImageOptimizerPass", "(", ")", ")", ";", "addPass", "(", "createNVPTXAssignValidGlobalNamesPass", "(", ")", ")", ";", "addPass", "(", "createGenericToNVVMPass", "(", ")", ")", ";", "addPass", "(", "createNVPTXLowerKernelArgsPass", "(", "&", "getNVPTXTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createSROAPass", "(", ")", ")", ";", "addPass", "(", "createNVPTXLowerAllocaPass", "(", ")", ")", ";", "addPass", "(", "createNVPTXFavorNonGenericAddrSpacesPass", "(", ")", ")", ";", "addPass", "(", "createDeadCodeEliminationPass", "(", ")", ")", ";", "addPass", "(", "createSeparateConstOffsetFromGEPPass", "(", ")", ")", ";", "addPass", "(", "createSpeculativeExecutionPass", "(", ")", ")", ";", "addPass", "(", "createStraightLineStrengthReducePass", "(", ")", ")", ";", "addEarlyCSEOrGVNPass", "(", ")", ";", "addPass", "(", "createNaryReassociatePass", "(", ")", ")", ";", "addPass", "(", "createEarlyCSEPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "addEarlyCSEOrGVNPass", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "aarch64_pop_regs", "(", "unsigned", "regno1", ",", "unsigned", "regno2", ",", "HOST_WIDE_INT", "adjustment", ",", "rtx", "*", "cfi_ops", ")", "{", "machine_mode", "mode", "=", "aarch64_reg_save_mode", "(", "regno1", ")", ";", "rtx", "reg1", "=", "gen_rtx_REG", "(", "mode", ",", "regno1", ")", ";", "*", "cfi_ops", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg1", ",", "*", "cfi_ops", ")", ";", "if", "(", "regno2", "==", "INVALID_REGNUM", ")", "{", "rtx", "mem", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "adjustment", ")", ";", "mem", "=", "gen_rtx_POST_MODIFY", "(", "Pmode", ",", "stack_pointer_rtx", ",", "mem", ")", ";", "emit_move_insn", "(", "reg1", ",", "gen_frame_mem", "(", "mode", ",", "mem", ")", ")", ";", "}", "else", "{", "rtx", "reg2", "=", "gen_rtx_REG", "(", "mode", ",", "regno2", ")", ";", "*", "cfi_ops", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg2", ",", "*", "cfi_ops", ")", ";", "emit_insn", "(", "aarch64_gen_loadwb_pair", "(", "mode", ",", "stack_pointer_rtx", ",", "reg1", ",", "reg2", ",", "adjustment", ")", ")", ";", "}", "}", "</s>" ]

[ "Pop", "the", "two", "registers", "numbered", "REGNO1", ",", "REGNO2", "from", "the", "stack", ",", "adjusting", "it", "afterwards", "by", "ADJUSTMENT", "and", "writing", "the", "appropriate", "REG_CFA_RESTORE", "notes", "into", "CFI_OPS", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "bool", "rs6000_secondary_reload_direct_move", "(", "enum", "rs6000_reg_type", "to_type", ",", "enum", "rs6000_reg_type", "from_type", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", ",", "bool", "altivec_p", ")", "{", "bool", "ret", "=", "false", ";", "enum", "insn_code", "icode", "=", "CODE_FOR_nothing", ";", "int", "cost", "=", "0", ";", "int", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "TARGET_POWERPC64", "&&", "size", "==", "16", ")", "{", "if", "(", "to_type", "==", "VSX_REG_TYPE", "&&", "from_type", "==", "GPR_REG_TYPE", ")", "{", "cost", "=", "3", ";", "icode", "=", "reg_addr", "[", "mode", "]", ".", "reload_vsx_gpr", ";", "}", "else", "if", "(", "to_type", "==", "GPR_REG_TYPE", "&&", "from_type", "==", "VSX_REG_TYPE", ")", "{", "cost", "=", "3", ";", "icode", "=", "reg_addr", "[", "mode", "]", ".", "reload_gpr_vsx", ";", "}", "}", "else", "if", "(", "TARGET_POWERPC64", "&&", "mode", "==", "SFmode", ")", "{", "if", "(", "to_type", "==", "GPR_REG_TYPE", "&&", "from_type", "==", "VSX_REG_TYPE", ")", "{", "cost", "=", "3", ";", "icode", "=", "reg_addr", "[", "mode", "]", ".", "reload_gpr_vsx", ";", "}", "else", "if", "(", "to_type", "==", "VSX_REG_TYPE", "&&", "from_type", "==", "GPR_REG_TYPE", ")", "{", "cost", "=", "2", ";", "icode", "=", "reg_addr", "[", "mode", "]", ".", "reload_vsx_gpr", ";", "}", "}", "else", "if", "(", "!", "TARGET_POWERPC64", "&&", "size", "==", "8", ")", "{", "if", "(", "to_type", "==", "VSX_REG_TYPE", "&&", "from_type", "==", "GPR_REG_TYPE", "&&", "!", "altivec_p", ")", "{", "cost", "=", "3", ";", "icode", "=", "reg_addr", "[", "mode", "]", ".", "reload_fpr_gpr", ";", "}", "}", "if", "(", "icode", "!=", "CODE_FOR_nothing", ")", "{", "ret", "=", "true", ";", "if", "(", "sri", ")", "{", "sri", "->", "icode", "=", "icode", ";", "sri", "->", "extra_cost", "=", "cost", ";", "}", "}", "return", "ret", ";", "}", "</s>" ]

[ "Power8", "helper", "function", "for", "rs6000_secondary_reload", ",", "handle", "all", "of", "the", "special", "direct", "moves", "that", "involve", "allocating", "an", "extra", "register", ",", "return", "the", "insn", "code", "of", "the", "helper", "function", "if", "there", "is", "such", "a", "function", "or", "CODE_FOR_nothing", "if", "not", "." ]

[ "powerpcspe", "0", "16", "3", "3", "3", "2", "8", "3" ]

[]

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

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

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "static", "void", "rs6000_invalid_builtin", "(", "enum", "rs6000_builtins", "fncode", ")", "{", "size_t", "uns_fncode", "=", "(", "size_t", ")", "fncode", ";", "const", "char", "*", "name", "=", "rs6000_builtin_info", "[", "uns_fncode", "]", ".", "name", ";", "HOST_WIDE_INT", "fnmask", "=", "rs6000_builtin_info", "[", "uns_fncode", "]", ".", "mask", ";", "gcc_assert", "(", "name", "!=", "NULL", ")", ";", "if", "(", "(", "fnmask", "&", "RS6000_BTM_CELL", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s is only valid for the cell processor\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_VSX", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s requires the -mvsx option\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_HTM", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s requires the -mhtm option\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_ALTIVEC", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s requires the -maltivec option\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_PAIRED", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s requires the -mpaired option\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_SPE", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s requires the -mspe option\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "(", "RS6000_BTM_DFP", "|", "RS6000_BTM_P8_VECTOR", ")", ")", "==", "(", "RS6000_BTM_DFP", "|", "RS6000_BTM_P8_VECTOR", ")", ")", "error", "(", "\"Builtin function %s requires the -mhard-dfp and\"", "\" -mpower8-vector options\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_DFP", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s requires the -mhard-dfp option\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_P8_VECTOR", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s requires the -mpower8-vector option\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "(", "RS6000_BTM_P9_VECTOR", "|", "RS6000_BTM_64BIT", ")", ")", "==", "(", "RS6000_BTM_P9_VECTOR", "|", "RS6000_BTM_64BIT", ")", ")", "error", "(", "\"Builtin function %s requires the -mcpu=power9 and\"", "\" -m64 options\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_P9_VECTOR", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s requires the -mcpu=power9 option\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "(", "RS6000_BTM_P9_MISC", "|", "RS6000_BTM_64BIT", ")", ")", "==", "(", "RS6000_BTM_P9_MISC", "|", "RS6000_BTM_64BIT", ")", ")", "error", "(", "\"Builtin function %s requires the -mcpu=power9 and\"", "\" -m64 options\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_P9_MISC", ")", "==", "RS6000_BTM_P9_MISC", ")", "error", "(", "\"Builtin function %s requires the -mcpu=power9 option\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "(", "RS6000_BTM_HARD_FLOAT", "|", "RS6000_BTM_LDBL128", ")", ")", "==", "(", "RS6000_BTM_HARD_FLOAT", "|", "RS6000_BTM_LDBL128", ")", ")", "error", "(", "\"Builtin function %s requires the -mhard-float and\"", "\" -mlong-double-128 options\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_HARD_FLOAT", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s requires the -mhard-float option\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_FLOAT128", ")", "!=", "0", ")", "error", "(", "\"Builtin function %s requires the -mfloat128 option\"", ",", "name", ")", ";", "else", "error", "(", "\"Builtin function %s is not supported with the current options\"", ",", "name", ")", ";", "}", "</s>" ]

[ "Raise", "an", "error", "message", "for", "a", "builtin", "function", "that", "is", "called", "without", "the", "appropriate", "target", "options", "being", "set", "." ]

[ "rs6000", "0", "\"Builtin function %s is only valid for the cell processor\"", "0", "\"Builtin function %s requires the -mvsx option\"", "0", "\"Builtin function %s requires the -mhtm option\"", "0", "\"Builtin function %s requires the -maltivec option\"", "0", "\"Builtin function %s requires the -mpaired option\"", "0", "\"Builtin function %s requires the -mspe option\"", "\"Builtin function %s requires the -mhard-dfp and\"", "\" -mpower8-vector options\"", "0", "\"Builtin function %s requires the -mhard-dfp option\"", "0", "\"Builtin function %s requires the -mpower8-vector option\"", "\"Builtin function %s requires the -mcpu=power9 and\"", "\" -m64 options\"", "0", "\"Builtin function %s requires the -mcpu=power9 option\"", "\"Builtin function %s requires the -mcpu=power9 and\"", "\" -m64 options\"", "\"Builtin function %s requires the -mcpu=power9 option\"", "\"Builtin function %s requires the -mhard-float and\"", "\" -mlong-double-128 options\"", "0", "\"Builtin function %s requires the -mhard-float option\"", "0", "\"Builtin function %s requires the -mfloat128 option\"", "\"Builtin function %s is not supported with the current options\"" ]

[]

[ "<s>", "static", "void", "mips16e_mask_registers", "(", "unsigned", "int", "*", "mask_ptr", ",", "const", "unsigned", "char", "*", "regs", ",", "unsigned", "int", "size", ",", "unsigned", "int", "*", "num_regs_ptr", ")", "{", "unsigned", "int", "i", ";", "i", "=", "mips16e_find_first_register", "(", "*", "mask_ptr", ",", "regs", ",", "size", ")", ";", "for", "(", "i", "++", ";", "i", "<", "size", ";", "i", "++", ")", "if", "(", "!", "BITSET_P", "(", "*", "mask_ptr", ",", "regs", "[", "i", "]", ")", ")", "{", "*", "num_regs_ptr", "+=", "1", ";", "*", "mask_ptr", "|=", "1", "<<", "regs", "[", "i", "]", ";", "}", "}", "</s>" ]

[ "*", "MASK_PTR", "is", "a", "mask", "of", "general-purpose", "registers", "and", "*", "NUM_REGS_PTR", "is", "the", "number", "of", "set", "bits", ".", "If", "*", "MASK_PTR", "contains", "REGS", "[", "X", "]", "for", "some", "X", "in", "[", "0", ",", "SIZE", ")", ",", "adjust", "*", "MASK_PTR", "and", "*", "NUM_REGS_PTR", "so", "that", "the", "same", "is", "true", "for", "all", "indexes", "(", "X", ",", "SIZE", ")", "." ]

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

[]

[ "<s>", "static", "const", "char", "*", "arm_invalid_parameter_type", "(", "const_tree", "t", ")", "{", "if", "(", "SCALAR_FLOAT_TYPE_P", "(", "t", ")", "&&", "TYPE_PRECISION", "(", "t", ")", "==", "16", ")", "return", "N_", "(", "\"function parameters cannot have __fp16 type\"", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Implement", "TARGET_INVALID_PARAMETER_TYPE", "." ]

[ "arm", "16", "\"function parameters cannot have __fp16 type\"" ]

[]

[ "<s>", "int", "MipsAsmParser", "::", "tryParseRegister", "(", "bool", "is64BitReg", ")", "{", "const", "AsmToken", "&", "Tok", "=", "Parser", ".", "getTok", "(", ")", ";", "int", "RegNum", "=", "-", "1", ";", "if", "(", "Tok", ".", "is", "(", "AsmToken", "::", "Identifier", ")", ")", "{", "std", "::", "string", "lowerCase", "=", "Tok", ".", "getString", "(", ")", ".", "lower", "(", ")", ";", "RegNum", "=", "matchRegisterName", "(", "lowerCase", ",", "is64BitReg", ")", ";", "}", "else", "if", "(", "Tok", ".", "is", "(", "AsmToken", "::", "Integer", ")", ")", "RegNum", "=", "matchRegisterByNumber", "(", "static_cast", "<", "unsigned", ">", "(", "Tok", ".", "getIntVal", "(", ")", ")", ",", "is64BitReg", "?", "Mips", "::", "CPU64RegsRegClassID", ":", "Mips", "::", "CPURegsRegClassID", ")", ";", "return", "RegNum", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "1", "Mips::CPU64RegsRegClassID", "Mips::CPURegsRegClassID" ]

[]

[ "<s>", "const", "X86InstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "getTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "StringRef", "X86TargetLowering", "::", "getStackProbeSymbolName", "(", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"probe-stack\"", ")", ")", "return", "MF", ".", "getFunction", "(", ")", ".", "getFnAttribute", "(", "\"probe-stack\"", ")", ".", "getValueAsString", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isOSWindows", "(", ")", "||", "Subtarget", ".", "isTargetMachO", "(", ")", "||", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"no-stack-arg-probe\"", ")", ")", "return", "\"\"", ";", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "return", "Subtarget", ".", "isTargetCygMing", "(", ")", "?", "\"___chkstk_ms\"", ":", "\"__chkstk\"", ";", "return", "Subtarget", ".", "isTargetCygMing", "(", ")", "?", "\"_alloca\"", ":", "\"_chkstk\"", ";", "}", "</s>" ]

[ "Returns", "the", "name", "of", "the", "symbol", "used", "to", "emit", "stack", "probes", "or", "the", "empty", "string", "if", "not", "applicable", "." ]

[ "X86", "X86", "\"probe-stack\"", "\"probe-stack\"", "\"no-stack-arg-probe\"", "\"\"", "\"___chkstk_ms\"", "\"__chkstk\"", "\"_alloca\"", "\"_chkstk\"" ]

[]

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

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

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

[]

[ "<s>", "const", "LegalizerInfo", "*", "X86Subtarget", "::", "getLegalizerInfo", "(", ")", "const", "{", "return", "Legalizer", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Expose", "LegalizerInfo", "so", "the", "clients", "can", "re-use", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "void", "ix86_emit_restore_reg_using_pop", "(", "rtx", "reg", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "rtx_insn", "*", "insn", "=", "emit_insn", "(", "gen_pop", "(", "reg", ")", ")", ";", "ix86_add_cfa_restore_note", "(", "insn", ",", "reg", ",", "m", "->", "fs", ".", "sp_offset", ")", ";", "m", "->", "fs", ".", "sp_offset", "-=", "UNITS_PER_WORD", ";", "if", "(", "m", "->", "fs", ".", "cfa_reg", "==", "crtl", "->", "drap_reg", "&&", "REGNO", "(", "reg", ")", "==", "REGNO", "(", "crtl", "->", "drap_reg", ")", ")", "{", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "m", "->", "fs", ".", "drap_valid", "=", "true", ";", "return", ";", "}", "if", "(", "m", "->", "fs", ".", "cfa_reg", "==", "stack_pointer_rtx", ")", "{", "rtx", "x", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "UNITS_PER_WORD", ")", ";", "x", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "x", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "x", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "m", "->", "fs", ".", "cfa_offset", "-=", "UNITS_PER_WORD", ";", "}", "if", "(", "reg", "==", "hard_frame_pointer_rtx", ")", "{", "m", "->", "fs", ".", "fp_valid", "=", "false", ";", "if", "(", "m", "->", "fs", ".", "cfa_reg", "==", "hard_frame_pointer_rtx", ")", "{", "m", "->", "fs", ".", "cfa_reg", "=", "stack_pointer_rtx", ";", "m", "->", "fs", ".", "cfa_offset", "-=", "UNITS_PER_WORD", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "m", "->", "fs", ".", "cfa_offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "}", "</s>" ]

[ "Emit", "code", "to", "restore", "REG", "using", "a", "POP", "insn", "." ]

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

[]

[ "<s>", "BitVector", "PPCRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "PPCFrameLowering", "*", "PPCFI", "=", "static_cast", "<", "const", "PPCFrameLowering", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R0", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R1", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "LR", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "LR8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "RM", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "R2", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R13", ")", ";", "}", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "R13", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R31", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X0", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X1", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X13", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X31", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "X2", ")", ";", "}", "}", "if", "(", "PPCFI", "->", "needsFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "R31", ")", ";", "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::R0", "PPC::R1", "PPC::LR", "PPC::LR8", "PPC::RM", "PPC::R2", "PPC::R13", "PPC", "PPC::R13", "PPC::R31", "PPC::X0", "PPC::X1", "PPC::X13", "PPC::X31", "PPC::X2", "PPC", "PPC::R31" ]

[]

[ "<s>", "char", "*", "construct_restore_jr", "(", "rtx", "op", ")", "{", "int", "count", "=", "XVECLEN", "(", "op", ",", "0", ")", ";", "int", "stack_bytes", ";", "unsigned", "long", "int", "mask", ";", "unsigned", "long", "int", "first", ";", "unsigned", "long", "int", "last", ";", "int", "i", ";", "static", "char", "buff", "[", "100", "]", ";", "if", "(", "count", "<=", "2", ")", "{", "error", "(", "\"bogus JR construction: %d\"", ",", "count", ")", ";", "return", "NULL", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "XVECEXP", "(", "op", ",", "0", ",", "1", ")", ")", "==", "SET", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "0", ",", "1", ")", ")", ")", "==", "PLUS", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "0", ",", "1", ")", ")", ",", "1", ")", ")", "==", "CONST_INT", ")", ";", "stack_bytes", "=", "INTVAL", "(", "XEXP", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "0", ",", "1", ")", ")", ",", "1", ")", ")", ";", "stack_bytes", "-=", "(", "count", "-", "2", ")", "*", "4", ";", "if", "(", "stack_bytes", "!=", "0", "&&", "stack_bytes", "!=", "16", ")", "{", "error", "(", "\"bad amount of stack space removal: %d\"", ",", "stack_bytes", ")", ";", "return", "NULL", ";", "}", "mask", "=", "0", ";", "for", "(", "i", "=", "2", ";", "i", "<", "count", ";", "i", "++", ")", "{", "rtx", "vector_element", "=", "XVECEXP", "(", "op", ",", "0", ",", "i", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "vector_element", ")", "==", "SET", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_DEST", "(", "vector_element", ")", ")", "==", "REG", ")", ";", "gcc_assert", "(", "register_is_ok_for_epilogue", "(", "SET_DEST", "(", "vector_element", ")", ",", "SImode", ")", ")", ";", "mask", "|=", "1", "<<", "REGNO", "(", "SET_DEST", "(", "vector_element", ")", ")", ";", "}", "for", "(", "first", "=", "0", ";", "first", "<", "32", ";", "first", "++", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "first", ")", ")", "break", ";", "}", "gcc_assert", "(", "first", "<", "32", ")", ";", "if", "(", "mask", "&", "(", "1", "<<", "LINK_POINTER_REGNUM", ")", ")", "{", "gcc_assert", "(", "stack_bytes", "==", "16", ")", ";", "last", "=", "LINK_POINTER_REGNUM", ";", "}", "else", "{", "gcc_assert", "(", "!", "stack_bytes", ")", ";", "gcc_assert", "(", "mask", "&", "(", "1", "<<", "29", ")", ")", ";", "last", "=", "29", ";", "}", "if", "(", "TARGET_LONG_CALLS", ")", "{", "char", "name", "[", "40", "]", ";", "if", "(", "first", "==", "last", ")", "sprintf", "(", "name", ",", "\"__return_%s\"", ",", "reg_names", "[", "first", "]", ")", ";", "else", "sprintf", "(", "name", ",", "\"__return_%s_%s\"", ",", "reg_names", "[", "first", "]", ",", "reg_names", "[", "last", "]", ")", ";", "sprintf", "(", "buff", ",", "\"movhi hi(%s), r0, r6\\n\\tmovea lo(%s), r6, r6\\n\\tjmp r6\"", ",", "name", ",", "name", ")", ";", "}", "else", "{", "if", "(", "first", "==", "last", ")", "sprintf", "(", "buff", ",", "\"jr __return_%s\"", ",", "reg_names", "[", "first", "]", ")", ";", "else", "sprintf", "(", "buff", ",", "\"jr __return_%s_%s\"", ",", "reg_names", "[", "first", "]", ",", "reg_names", "[", "last", "]", ")", ";", "}", "return", "buff", ";", "}", "</s>" ]

[ "Construct", "a", "JR", "instruction", "to", "a", "routine", "that", "will", "perform", "the", "equivalent", "of", "the", "RTL", "passed", "in", "as", "an", "argument", ".", "This", "RTL", "is", "a", "function", "epilogue", "that", "pops", "registers", "off", "the", "stack", "and", "possibly", "releases", "some", "extra", "stack", "space", "as", "well", ".", "The", "code", "has", "already", "verified", "that", "the", "RTL", "matches", "these", "requirements", "." ]

[ "v850", "0", "100", "2", "\"bogus JR construction: %d\"", "0", "1", "0", "1", "0", "1", "1", "0", "1", "1", "2", "4", "0", "16", "\"bad amount of stack space removal: %d\"", "0", "2", "0", "1", "0", "32", "1", "32", "1", "16", "1", "29", "29", "40", "\"__return_%s\"", "\"__return_%s_%s\"", "\"movhi hi(%s), r0, r6\\n\\tmovea lo(%s), r6, r6\\n\\tjmp r6\"", "\"jr __return_%s\"", "\"jr __return_%s_%s\"" ]

[]

[ "<s>", "static", "bool", "is_fusable_store", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "str_mem", ")", "{", "if", "(", "is_store_insn", "(", "insn", ",", "str_mem", ")", "&&", "get_attr_prefixed", "(", "insn", ")", "==", "PREFIXED_NO", "&&", "get_attr_update", "(", "insn", ")", "==", "UPDATE_NO", "&&", "get_attr_indexed", "(", "insn", ")", "==", "INDEXED_NO", ")", "{", "if", "(", "!", "MEM_SIZE_KNOWN_P", "(", "*", "str_mem", ")", ")", "return", "false", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "*", "str_mem", ")", ";", "HOST_WIDE_INT", "size", "=", "MEM_SIZE", "(", "*", "str_mem", ")", ";", "if", "(", "INTEGRAL_MODE_P", "(", "mode", ")", ")", "return", "(", "size", "==", "4", "||", "size", "==", "8", ")", ";", "else", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", ")", "return", "(", "size", "==", "8", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Determine", "if", "INSN", "is", "a", "store", "to", "memory", "that", "can", "be", "fused", "with", "a", "similar", "adjacent", "store", "." ]

[ "rs6000", "4", "8", "8" ]

[]

[ "<s>", "SDValue", "NyuziTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "LowerINSERT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "LowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SCALAR_TO_VECTOR", ":", "return", "LowerSCALAR_TO_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VSELECT", ":", "return", "LowerVSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "LowerFDIV", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FNEG", ":", "return", "LowerFNEG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FABS", ":", "return", "LowerFABS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTLZ_ZERO_UNDEF", ":", "return", "LowerCTLZ_ZERO_UNDEF", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTTZ_ZERO_UNDEF", ":", "return", "LowerCTTZ_ZERO_UNDEF", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerUINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "LowerSIGN_EXTEND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "LowerZERO_EXTEND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "TRUNCATE", ":", "return", "LowerTRUNCATE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_XINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "}", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi", "ISD::GlobalAddress", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::INSERT_VECTOR_ELT", "ISD::EXTRACT_VECTOR_ELT", "ISD::SCALAR_TO_VECTOR", "ISD::SELECT_CC", "ISD::SELECT", "ISD::VSELECT", "ISD::SETCC", "ISD::ConstantPool", "ISD::FDIV", "ISD::FNEG", "ISD::FABS", "ISD::BlockAddress", "ISD::VASTART", "ISD::CTLZ_ZERO_UNDEF", "ISD::CTTZ_ZERO_UNDEF", "ISD::UINT_TO_FP", "ISD::SINT_TO_FP", "ISD::FRAMEADDR", "ISD::RETURNADDR", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::TRUNCATE", "ISD::FP_TO_SINT", "ISD::FP_TO_UINT", "ISD::JumpTable", "\"Should not custom lower this!\"" ]

[]

[ "<s>", "static", "void", "c6x_mark_reg_written", "(", "rtx", "reg", ",", "int", "cycles", ")", "{", "unsigned", "regno", "=", "REGNO", "(", "reg", ")", ";", "unsigned", "nregs", "=", "REG_NREGS", "(", "reg", ")", ";", "while", "(", "nregs", "--", ">", "0", ")", "ss", ".", "reg_set_in_cycle", "[", "regno", "+", "nregs", "]", "=", "cycles", ";", "}", "</s>" ]

[ "Note", "that", "register", "REG", "is", "written", "in", "cycle", "CYCLES", "." ]

[ "c6x", "0" ]

[]

[ "<s>", "void", "SystemZConstantPoolValue", "::", "print", "(", "raw_ostream", "&", "O", ")", "const", "{", "O", "<<", "GV", "<<", "\"@\"", "<<", "int", "(", "Modifier", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "\"@\"" ]

[]

[ "<s>", "bool", "HexagonHardwareLoops", "::", "isDead", "(", "const", "MachineInstr", "*", "MI", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "DeadPhis", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "MRI", "->", "use_nodbg_empty", "(", "Reg", ")", ")", "continue", ";", "typedef", "MachineRegisterInfo", "::", "use_nodbg_iterator", "use_nodbg_iterator", ";", "use_nodbg_iterator", "I", "=", "MRI", "->", "use_nodbg_begin", "(", "Reg", ")", ";", "use_nodbg_iterator", "End", "=", "MRI", "->", "use_nodbg_end", "(", ")", ";", "if", "(", "std", "::", "next", "(", "I", ")", "!=", "End", "||", "!", "I", ".", "getOperand", "(", ")", ".", "getParent", "(", ")", "->", "isPHI", "(", ")", ")", "return", "false", ";", "MachineInstr", "*", "OnePhi", "=", "I", ".", "getOperand", "(", ")", ".", "getParent", "(", ")", ";", "for", "(", "unsigned", "j", "=", "0", ",", "f", "=", "OnePhi", "->", "getNumOperands", "(", ")", ";", "j", "!=", "f", ";", "++", "j", ")", "{", "const", "MachineOperand", "&", "OPO", "=", "OnePhi", "->", "getOperand", "(", "j", ")", ";", "if", "(", "!", "OPO", ".", "isReg", "(", ")", "||", "!", "OPO", ".", "isDef", "(", ")", ")", "continue", ";", "unsigned", "OPReg", "=", "OPO", ".", "getReg", "(", ")", ";", "use_nodbg_iterator", "nextJ", ";", "for", "(", "use_nodbg_iterator", "J", "=", "MRI", "->", "use_nodbg_begin", "(", "OPReg", ")", ";", "J", "!=", "End", ";", "J", "=", "nextJ", ")", "{", "nextJ", "=", "std", "::", "next", "(", "J", ")", ";", "MachineOperand", "&", "Use", "=", "J", ".", "getOperand", "(", ")", ";", "MachineInstr", "*", "UseMI", "=", "Use", ".", "getParent", "(", ")", ";", "if", "(", "MI", "!=", "UseMI", ")", "return", "false", ";", "}", "}", "DeadPhis", ".", "push_back", "(", "OnePhi", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isDead", "-", "Returns", "true", "if", "this", "is", "a", "dead", "def", "kill", "slot", "." ]

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

[]

[ "<s>", "void", "HexagonPassConfig", "::", "addIRPasses", "(", ")", "{", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "bool", "NoOpt", "=", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "!", "NoOpt", ")", "{", "if", "(", "EnableLoopPrefetch", ")", "addPass", "(", "createLoopDataPrefetchPass", "(", ")", ")", ";", "if", "(", "EnableCommGEP", ")", "addPass", "(", "createHexagonCommonGEP", "(", ")", ")", ";", "if", "(", "EnableGenExtract", ")", "addPass", "(", "createHexagonGenExtract", "(", ")", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isFunctionSafeToOutlineFrom", "(", "MachineFunction", "&", "MF", ",", "bool", "OutlineFromLinkOnceODRs", ")", "const", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "NoRedZone", ")", ")", "return", "false", ";", "if", "(", "!", "OutlineFromLinkOnceODRs", "&&", "F", "->", "hasLinkOnceODRLinkage", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]