Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "SystemZSelectionDAGInfo", "::", "EmitTargetCodeForMemchr", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "SDValue", "Chain", ",", "SDValue", "Src", ",", "SDValue", "Char", ",", "SDValue", "Length", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "EVT", "PtrVT", "=", "Src", ".", "getValueType", "(", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "PtrVT", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ")", ";", "Length", "=", "DAG", ".", "getZExtOrTrunc", "(", "Length", ",", "DL", ",", "PtrVT", ")", ";", "Char", "=", "DAG", ".", "getZExtOrTrunc", "(", "Char", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "Char", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "MVT", "::", "i32", ",", "Char", ",", "DAG", ".", "getConstant", "(", "255", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "Limit", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "PtrVT", ",", "Src", ",", "Length", ")", ";", "SDValue", "End", "=", "DAG", ".", "getNode", "(", "SystemZISD", "::", "SEARCH_STRING", ",", "DL", ",", "VTs", ",", "Chain", ",", "Limit", ",", "Src", ",", "Char", ")", ";", "SDValue", "CCReg", "=", "End", ".", "getValue", "(", "1", ")", ";", "Chain", "=", "End", ".", "getValue", "(", "2", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "End", ",", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "PtrVT", ")", ",", "DAG", ".", "getConstant", "(", "SystemZ", "::", "CCMASK_SRST", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getConstant", "(", "SystemZ", "::", "CCMASK_SRST_FOUND", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "CCReg", "}", ";", "End", "=", "DAG", ".", "getNode", "(", "SystemZISD", "::", "SELECT_CCMASK", ",", "DL", ",", "PtrVT", ",", "Ops", ")", ";", "return", "std", "::", "make_pair", "(", "End", ",", "Chain", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memchr", ",", "in", "cases", "where", "that", "is", "faster", "than", "a", "libcall", "." ]

[ "SystemZ", "SystemZ", "MVT::i32", "MVT::Other", "MVT::i32", "ISD::AND", "MVT::i32", "255", "MVT::i32", "ISD::ADD", "SystemZISD::SEARCH_STRING", "1", "2", "0", "SystemZ::CCMASK_SRST", "MVT::i32", "SystemZ::CCMASK_SRST_FOUND", "MVT::i32", "SystemZISD::SELECT_CCMASK" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "assert", "(", "HexagonMCInstrInfo", "::", "isBundle", "(", "Inst", ")", "&&", "\"Hexagon relaxInstruction only works on bundles\"", ")", ";", "Res", ".", "setOpcode", "(", "Hexagon", "::", "BUNDLE", ")", ";", "Res", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ")", ")", ";", "bool", "Update", "=", "false", ";", "for", "(", "auto", "&", "I", ":", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "Inst", ")", ")", "{", "MCInst", "&", "CrntHMI", "=", "const_cast", "<", "MCInst", "&", ">", "(", "*", "I", ".", "getInst", "(", ")", ")", ";", "if", "(", "*", "RelaxTarget", "==", "&", "CrntHMI", ")", "{", "Update", "=", "true", ";", "assert", "(", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "Res", ")", "<", "HEXAGON_PACKET_SIZE", ")", "&&", "\"No room to insert extender for relaxation\"", ")", ";", "MCInst", "*", "HMIx", "=", "takeExtender", "(", ")", ";", "*", "HMIx", "=", "HexagonMCInstrInfo", "::", "deriveExtender", "(", "*", "MCII", ",", "CrntHMI", ",", "HexagonMCInstrInfo", "::", "getExtendableOperand", "(", "*", "MCII", ",", "CrntHMI", ")", ")", ";", "Res", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "HMIx", ")", ")", ";", "*", "RelaxTarget", "=", "nullptr", ";", "}", "Res", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "I", ".", "getInst", "(", ")", ")", ")", ";", "}", "(", "void", ")", "Update", ";", "assert", "(", "Update", "&&", "\"Didn't find relaxation target\"", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\"Hexagon relaxInstruction only works on bundles\"", "Hexagon::BUNDLE", "0", "Hexagon", "Hexagon", "\"No room to insert extender for relaxation\"", "Hexagon", "Hexagon", "\"Didn't find relaxation target\"" ]

[]

[ "<s>", "void", "rs6000_aix_asm_output_dwarf_table_ref", "(", "char", "*", "frame_table_label", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t.ref %s\\n\"", ",", "(", "*", "targetm", ".", "strip_name_encoding", ")", "(", "frame_table_label", ")", ")", ";", "}", "</s>" ]

[ "Issue", "assembly", "directives", "that", "create", "a", "reference", "to", "the", "given", "DWARF", "FRAME_TABLE_LABEL", "from", "the", "current", "function", "section", "." ]

[ "powerpcspe", "\"\\t.ref %s\\n\"" ]

[]

[ "<s>", "static", "void", "arm_option_override_internal", "(", "struct", "gcc_options", "*", "opts", ",", "struct", "gcc_options", "*", "opts_set", ")", "{", "arm_override_options_after_change_1", "(", "opts", ",", "opts_set", ")", ";", "if", "(", "TARGET_INTERWORK", "&&", "!", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_thumb", ")", ")", "{", "opts", "->", "x_target_flags", "&=", "~", "MASK_INTERWORK", ";", "}", "if", "(", "TARGET_THUMB_P", "(", "opts", "->", "x_target_flags", ")", "&&", "!", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_thumb", ")", ")", "{", "warning", "(", "0", ",", "\"target CPU does not support THUMB instructions\"", ")", ";", "opts", "->", "x_target_flags", "&=", "~", "MASK_THUMB", ";", "}", "if", "(", "TARGET_APCS_FRAME", "&&", "TARGET_THUMB_P", "(", "opts", "->", "x_target_flags", ")", ")", "{", "opts", "->", "x_target_flags", "&=", "~", "MASK_APCS_FRAME", ";", "}", "if", "(", "TARGET_THUMB_P", "(", "opts", "->", "x_target_flags", ")", "&&", "TARGET_CALLEE_INTERWORKING", ")", "opts", "->", "x_target_flags", "|=", "MASK_INTERWORK", ";", "cl_optimization", "*", "to", "=", "TREE_OPTIMIZATION", "(", "init_optimize", ")", ";", "if", "(", "!", "opts_set", "->", "x_arm_restrict_it", ")", "opts", "->", "x_arm_restrict_it", "=", "arm_arch8", ";", "if", "(", "!", "TARGET_THUMB2_P", "(", "opts", "->", "x_target_flags", ")", "||", "!", "arm_arch_notm", ")", "opts", "->", "x_arm_restrict_it", "=", "0", ";", "if", "(", "!", "opts_set", "->", "x_arm_restrict_it", "&&", "(", "opts_set", "->", "x_arm_cpu_string", "||", "opts_set", "->", "x_arm_tune_string", ")", ")", "opts", "->", "x_arm_restrict_it", "=", "0", ";", "if", "(", "!", "opts_set", "->", "x_unaligned_access", ")", "{", "opts", "->", "x_unaligned_access", "=", "(", "TARGET_32BIT_P", "(", "opts", "->", "x_target_flags", ")", "&&", "arm_arch6", "&&", "(", "arm_arch_notm", "||", "arm_arch7", ")", ")", ";", "}", "else", "if", "(", "opts", "->", "x_unaligned_access", "==", "1", "&&", "!", "(", "arm_arch6", "&&", "(", "arm_arch_notm", "||", "arm_arch7", ")", ")", ")", "{", "warning", "(", "0", ",", "\"target CPU does not support unaligned accesses\"", ")", ";", "opts", "->", "x_unaligned_access", "=", "0", ";", "}", "if", "(", "TARGET_THUMB1_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_flag_schedule_insns", "=", "0", ";", "else", "opts", "->", "x_flag_schedule_insns", "=", "to", "->", "x_flag_schedule_insns", ";", "if", "(", "optimize_function_for_size_p", "(", "cfun", ")", "&&", "TARGET_THUMB2_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_flag_shrink_wrap", "=", "false", ";", "else", "opts", "->", "x_flag_shrink_wrap", "=", "to", "->", "x_flag_shrink_wrap", ";", "if", "(", "TARGET_THUMB1_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_flag_ipa_ra", "=", "0", ";", "else", "opts", "->", "x_flag_ipa_ra", "=", "to", "->", "x_flag_ipa_ra", ";", "if", "(", "TARGET_THUMB2_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_inline_asm_unified", "=", "true", ";", "if", "(", "arm_stack_protector_guard", "==", "SSP_GLOBAL", "&&", "opts", "->", "x_arm_stack_protector_guard_offset_str", ")", "{", "error", "(", "\"incompatible options %<-mstack-protector-guard=global%> and \"", "\"%<-mstack-protector-guard-offset=%s%>\"", ",", "arm_stack_protector_guard_offset_str", ")", ";", "}", "if", "(", "opts", "->", "x_arm_stack_protector_guard_offset_str", ")", "{", "char", "*", "end", ";", "const", "char", "*", "str", "=", "arm_stack_protector_guard_offset_str", ";", "errno", "=", "0", ";", "long", "offs", "=", "strtol", "(", "arm_stack_protector_guard_offset_str", ",", "&", "end", ",", "0", ")", ";", "if", "(", "!", "*", "str", "||", "*", "end", "||", "errno", ")", "error", "(", "\"%qs is not a valid offset in %qs\"", ",", "str", ",", "\"-mstack-protector-guard-offset=\"", ")", ";", "arm_stack_protector_guard_offset", "=", "offs", ";", "}", "if", "(", "arm_current_function_pac_enabled_p", "(", ")", ")", "{", "if", "(", "!", "arm_arch8m_main", ")", "error", "(", "\"This architecture does not support branch protection \"", "\"instructions\"", ")", ";", "if", "(", "TARGET_TPCS_FRAME", ")", "sorry", "(", "\"Return address signing is not supported with %<-mtpcs-frame%>.\"", ")", ";", "}", "SUBTARGET_OVERRIDE_INTERNAL_OPTIONS", ";", "}", "</s>" ]

[ "Reset", "options", "between", "modes", "that", "the", "user", "has", "specified", "." ]

[ "arm", "0", "\"target CPU does not support THUMB instructions\"", "0", "0", "1", "0", "\"target CPU does not support unaligned accesses\"", "0", "0", "0", "\"incompatible options %<-mstack-protector-guard=global%> and \"", "\"%<-mstack-protector-guard-offset=%s%>\"", "0", "0", "\"%qs is not a valid offset in %qs\"", "\"-mstack-protector-guard-offset=\"", "\"This architecture does not support branch protection \"", "\"instructions\"", "\"Return address signing is not supported with %<-mtpcs-frame%>.\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "NVPTXTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'b'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Int1RegsRegClass", ")", ";", "case", "'c'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Int16RegsRegClass", ")", ";", "case", "'h'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Int16RegsRegClass", ")", ";", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Int32RegsRegClass", ")", ";", "case", "'l'", ":", "case", "'N'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Int64RegsRegClass", ")", ";", "case", "'f'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Float32RegsRegClass", ")", ";", "case", "'d'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Float64RegsRegClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "NVPTX", "NVPTX", "1", "0", "0U", "NVPTX::Int1RegsRegClass", "0U", "NVPTX::Int16RegsRegClass", "0U", "NVPTX::Int16RegsRegClass", "0U", "NVPTX::Int32RegsRegClass", "0U", "NVPTX::Int64RegsRegClass", "0U", "NVPTX::Float32RegsRegClass", "0U", "NVPTX::Float64RegsRegClass" ]

[]

[ "<s>", "BitVector", "X86RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "for", "(", "MCSubRegIterator", "I", "(", "X86", "::", "RSP", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "for", "(", "MCSubRegIterator", "I", "(", "X86", "::", "RIP", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "for", "(", "MCSubRegIterator", "I", "(", "X86", "::", "RBP", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "{", "CallingConv", "::", "ID", "CC", "=", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ";", "const", "uint32_t", "*", "RegMask", "=", "getCallPreservedMask", "(", "CC", ")", ";", "if", "(", "MachineOperand", "::", "clobbersPhysReg", "(", "RegMask", ",", "getBaseRegister", "(", ")", ")", ")", "report_fatal_error", "(", "\"Stack realignment in presence of dynamic allocas is not supported with\"", "\"this calling convention.\"", ")", ";", "for", "(", "MCSubRegIterator", "I", "(", "getBaseRegister", "(", ")", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "Reserved", ".", "set", "(", "X86", "::", "CS", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "SS", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "DS", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "ES", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "FS", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "GS", ")", ";", "for", "(", "unsigned", "n", "=", "0", ";", "n", "!=", "8", ";", "++", "n", ")", "Reserved", ".", "set", "(", "X86", "::", "ST0", "+", "n", ")", ";", "if", "(", "!", "Is64Bit", ")", "{", "Reserved", ".", "set", "(", "X86", "::", "SIL", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "DIL", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "BPL", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "SPL", ")", ";", "for", "(", "unsigned", "n", "=", "0", ";", "n", "!=", "8", ";", "++", "n", ")", "{", "for", "(", "MCRegAliasIterator", "AI", "(", "X86", "::", "R8", "+", "n", ",", "this", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Reserved", ".", "set", "(", "*", "AI", ")", ";", "for", "(", "MCRegAliasIterator", "AI", "(", "X86", "::", "XMM8", "+", "n", ",", "this", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Reserved", ".", "set", "(", "*", "AI", ")", ";", "}", "}", "if", "(", "!", "Is64Bit", "||", "!", "Subtarget", ".", "hasAVX512", "(", ")", ")", "{", "for", "(", "unsigned", "n", "=", "16", ";", "n", "!=", "32", ";", "++", "n", ")", "{", "for", "(", "MCRegAliasIterator", "AI", "(", "X86", "::", "XMM0", "+", "n", ",", "this", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Reserved", ".", "set", "(", "*", "AI", ")", ";", "}", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::RSP", "X86::RIP", "X86::RBP", "\"Stack realignment in presence of dynamic allocas is not supported with\"", "\"this calling convention.\"", "X86::CS", "X86::SS", "X86::DS", "X86::ES", "X86::FS", "X86::GS", "0", "8", "X86::ST0", "X86::SIL", "X86::DIL", "X86::BPL", "X86::SPL", "0", "8", "X86::R8", "X86::XMM8", "16", "32", "X86::XMM0" ]

[]

[ "<s>", "bool", "XtensaPassConfig", "::", "addPreISel", "(", ")", "{", "return", "false", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa" ]

[]

[ "<s>", "int", "rs6000_emit_vector_cond_expr", "(", "rtx", "dest", ",", "rtx", "op1", ",", "rtx", "op2", ",", "rtx", "cond", ",", "rtx", "cc_op0", ",", "rtx", "cc_op1", ")", "{", "enum", "machine_mode", "dest_mode", "=", "GET_MODE", "(", "dest", ")", ";", "enum", "rtx_code", "rcode", "=", "GET_CODE", "(", "cond", ")", ";", "rtx", "mask", ";", "if", "(", "!", "TARGET_ALTIVEC", ")", "return", "0", ";", "mask", "=", "rs6000_emit_vector_compare", "(", "rcode", ",", "cc_op0", ",", "cc_op1", ",", "dest_mode", ")", ";", "rs6000_emit_vector_select", "(", "dest", ",", "op1", ",", "op2", ",", "mask", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Emit", "vector", "conditional", "expression", ".", "DEST", "is", "destination", ".", "OP1", "and", "OP2", "are", "two", "VEC_COND_EXPR", "operands", ".", "CC_OP0", "and", "CC_OP1", "are", "the", "two", "operands", "for", "the", "relation", "operation", "COND", "." ]

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

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "isAsmClobberable", "(", "const", "MachineFunction", "&", "MF", ",", "MCRegister", "PhysReg", ")", "const", "{", "return", "!", "getReservedRegs", "(", "MF", ")", ".", "test", "(", "PhysReg", ")", ";", "}", "</s>" ]

[ "Returns", "false", "if", "we", "ca", "n't", "guarantee", "that", "Physreg", ",", "specified", "as", "an", "IR", "asm", "clobber", "constraint", ",", "will", "be", "preserved", "across", "the", "statement", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "const", "ARMSubtarget", "*", "ARMBaseTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "Attribute", "SFAttr", "=", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ";", "bool", "SoftFloat", "=", "!", "SFAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "SFAttr", ".", "getValueAsString", "(", ")", "==", "\"true\"", ":", "Options", ".", "UseSoftFloat", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "+", "(", "SoftFloat", "?", "\"use-soft-float=true\"", ":", "\"use-soft-float=false\"", ")", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "ARMSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "\"target-cpu\"", "\"target-features\"", "\"use-soft-float\"", "\"true\"", "\"use-soft-float=true\"", "\"use-soft-float=false\"", "ARM" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "isLoadFromStackSlotPostFE", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "isFrameLoadOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "{", "unsigned", "Reg", ";", "if", "(", "(", "Reg", "=", "isLoadFromStackSlot", "(", "MI", ",", "FrameIndex", ")", ")", ")", "return", "Reg", ";", "const", "MachineMemOperand", "*", "Dummy", ";", "return", "hasLoadFromStackSlot", "(", "MI", ",", "Dummy", ",", "FrameIndex", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlotPostFE", "-", "Check", "for", "post-frame", "ptr", "elimination", "stack", "locations", "as", "well", "." ]

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

[]

[ "<s>", "void", "add", "(", "HOST_WIDE_INT", "val", ")", "{", "asm_fprintf", "(", "t_file", ",", "\"\\tadds\\t%s, #\"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "dst_regname", ",", "val", ")", ";", "}", "</s>" ]

[ "Make", "function", "pointers", "for", "the", "various", "linear", "operators", "we", "can", "apply", "to", "compute", "a", "multiplicative", "value", "." ]

[ "arm", "\"\\tadds\\t%s, #\"", "\"\\n\"" ]

[]

[ "<s>", "void", "Z80FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "Z80MachineFunctionInfo", "*", "Z80FI", "=", "MF", ".", "getInfo", "<", "Z80MachineFunctionInfo", ">", "(", ")", ";", "const", "Z80InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Z80InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "uint64_t", "CallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "uint64_t", "FrameSize", "=", "Z80FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "StackSize", "+", "CallFrameSize", "-", "FrameSize", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "Z80", "::", "PUSH16r", ")", ")", "MBBI", "++", ";", "if", "(", "NumBytes", "||", "Z80FI", "->", "isNeedFP", "(", ")", ")", "{", "unsigned", "FP", "=", "TII", ".", "getRegisterInfo", "(", ")", ".", "getFrameRegister", "(", "MF", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Z80", "::", "LD16ri", ")", ",", "FP", ")", ".", "addImm", "(", "-", "NumBytes", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Z80", "::", "ADD16rSP", ")", ",", "FP", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Z80", "::", "LD16SPr", ")", ")", ".", "addReg", "(", "FP", ")", ";", "}", "}", "</s>" ]

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

[ "Z80", "Z80", "Z80", "Z80", "Z80", "Z80", "Z80", "Z80", "Z80::PUSH16r", "Z80", "Z80::LD16ri", "Z80::ADD16rSP", "Z80::LD16SPr" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_Mips", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "Mips", "Mips", "ISD::InputArg", "16", "Mips", "0", "1", "2", "0" ]

[]

[ "<s>", "void", "m32r_finalize_pic", "(", ")", "{", "}", "</s>" ]

[ "Emit", "special", "PIC", "prologues", "and", "epilogues", "." ]

[ "m32r" ]

[]

[ "<s>", "MVT", "MipsTargetLowering", "::", "getSetCCResultType", "(", "MVT", "VT", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "Mips", "Mips", "MVT::i32" ]

[]

[ "<s>", "unsigned", "DLXMachineFunctionInfo", "::", "getGlobalBaseReg", "(", ")", "{", "return", "GlobalBaseReg", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "DLX", "DLX" ]

[]

[ "<s>", "static", "ARM64Operand", "*", "CreateReg", "(", "unsigned", "RegNum", ",", "bool", "isVector", ",", "SMLoc", "S", ",", "SMLoc", "E", ",", "MCContext", "&", "Ctx", ")", "{", "ARM64Operand", "*", "Op", "=", "new", "ARM64Operand", "(", "k_Register", ",", "Ctx", ")", ";", "Op", "->", "Reg", ".", "RegNum", "=", "RegNum", ";", "Op", "->", "Reg", ".", "isVector", "=", "isVector", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "ARM64", "ARM64" ]

[]

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

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

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

[]

[ "<s>", "bool", "cris_simple_epilogue", "(", "void", ")", "{", "unsigned", "int", "regno", ";", "unsigned", "int", "reglimit", "=", "STACK_POINTER_REGNUM", ";", "if", "(", "!", "reload_completed", "||", "frame_pointer_needed", "||", "get_frame_size", "(", ")", "!=", "0", "||", "crtl", "->", "args", ".", "pretend_args_size", "||", "crtl", "->", "args", ".", "size", "||", "crtl", "->", "outgoing_args_size", "||", "crtl", "->", "calls_eh_return", "||", "!", "TARGET_PROLOGUE_EPILOGUE", ")", "return", "false", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "reglimit", ";", "regno", "++", ")", "if", "(", "cris_reg_saved_in_regsave_area", "(", "regno", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "!", "=", "0", "if", "the", "return", "sequence", "for", "the", "current", "function", "is", "short", ",", "like", "``", "ret", "''", "or", "``", "jump", "[", "sp+", "]", "''", ".", "Prior", "to", "reloading", ",", "we", "ca", "n't", "tell", "how", "many", "registers", "must", "be", "saved", ",", "so", "return", "0", "then", "." ]

[ "cris", "0", "0" ]

[]

[ "<s>", "enum", "aarch64_symbol_type", "aarch64_classify_symbol", "(", "rtx", "x", ",", "HOST_WIDE_INT", "offset", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "{", "switch", "(", "aarch64_cmodel", ")", "{", "case", "AARCH64_CMODEL_LARGE", ":", "return", "SYMBOL_FORCE_TO_MEM", ";", "case", "AARCH64_CMODEL_TINY_PIC", ":", "case", "AARCH64_CMODEL_TINY", ":", "return", "SYMBOL_TINY_ABSOLUTE", ";", "case", "AARCH64_CMODEL_SMALL_SPIC", ":", "case", "AARCH64_CMODEL_SMALL_PIC", ":", "case", "AARCH64_CMODEL_SMALL", ":", "return", "SYMBOL_SMALL_ABSOLUTE", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "{", "if", "(", "aarch64_tls_symbol_p", "(", "x", ")", ")", "return", "aarch64_classify_tls_symbol", "(", "x", ")", ";", "switch", "(", "aarch64_cmodel", ")", "{", "case", "AARCH64_CMODEL_TINY", ":", "if", "(", "(", "SYMBOL_REF_WEAK", "(", "x", ")", "&&", "!", "aarch64_symbol_binds_local_p", "(", "x", ")", ")", "||", "!", "IN_RANGE", "(", "offset", ",", "-", "1048575", ",", "1048575", ")", ")", "return", "SYMBOL_FORCE_TO_MEM", ";", "return", "SYMBOL_TINY_ABSOLUTE", ";", "case", "AARCH64_CMODEL_SMALL", ":", "if", "(", "(", "SYMBOL_REF_WEAK", "(", "x", ")", "&&", "!", "aarch64_symbol_binds_local_p", "(", "x", ")", ")", "||", "!", "IN_RANGE", "(", "offset", ",", "HOST_WIDE_INT_C", "(", "-", "4294967263", ")", ",", "HOST_WIDE_INT_C", "(", "4294967264", ")", ")", ")", "return", "SYMBOL_FORCE_TO_MEM", ";", "return", "SYMBOL_SMALL_ABSOLUTE", ";", "case", "AARCH64_CMODEL_TINY_PIC", ":", "if", "(", "!", "aarch64_symbol_binds_local_p", "(", "x", ")", ")", "return", "SYMBOL_TINY_GOT", ";", "return", "SYMBOL_TINY_ABSOLUTE", ";", "case", "AARCH64_CMODEL_SMALL_SPIC", ":", "case", "AARCH64_CMODEL_SMALL_PIC", ":", "if", "(", "!", "aarch64_symbol_binds_local_p", "(", "x", ")", ")", "return", "(", "aarch64_cmodel", "==", "AARCH64_CMODEL_SMALL_SPIC", "?", "SYMBOL_SMALL_GOT_28K", ":", "SYMBOL_SMALL_GOT_4G", ")", ";", "return", "SYMBOL_SMALL_ABSOLUTE", ";", "case", "AARCH64_CMODEL_LARGE", ":", "if", "(", "!", "aarch64_pcrelative_literal_loads", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", ")", "return", "SYMBOL_SMALL_ABSOLUTE", ";", "else", "return", "SYMBOL_FORCE_TO_MEM", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "return", "SYMBOL_FORCE_TO_MEM", ";", "}", "</s>" ]

[ "Return", "the", "method", "that", "should", "be", "used", "to", "access", "SYMBOL_REF", "or", "LABEL_REF", "X", "." ]

[ "aarch64", "1048575", "1048575", "4294967263", "4294967264" ]

[]

[ "<s>", "const", "MCExpr", "*", "X86_64MachoTargetObjectFile", "::", "getTTypeGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "Mangler", "*", "Mang", ",", "MachineModuleInfo", "*", "MMI", ",", "unsigned", "Encoding", ",", "MCStreamer", "&", "Streamer", ")", "const", "{", "if", "(", "Encoding", "&", "(", "DW_EH_PE_indirect", "|", "DW_EH_PE_pcrel", ")", ")", "{", "const", "MCSymbol", "*", "Sym", "=", "getSymbol", "(", "*", "Mang", ",", "GV", ")", ";", "const", "MCExpr", "*", "Res", "=", "MCSymbolRefExpr", "::", "Create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_GOTPCREL", ",", "getContext", "(", ")", ")", ";", "const", "MCExpr", "*", "Four", "=", "MCConstantExpr", "::", "Create", "(", "4", ",", "getContext", "(", ")", ")", ";", "return", "MCBinaryExpr", "::", "CreateAdd", "(", "Res", ",", "Four", ",", "getContext", "(", ")", ")", ";", "}", "return", "TargetLoweringObjectFileMachO", "::", "getTTypeGlobalReference", "(", "GV", ",", "Mang", ",", "MMI", ",", "Encoding", ",", "Streamer", ")", ";", "}", "</s>" ]

[ "The", "mach-o", "version", "of", "this", "method", "defaults", "to", "returning", "a", "stub", "reference", "." ]

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

[]

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

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

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

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"WebAssembly Lower @llvm.global_dtors\"", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"WebAssembly Lower @llvm.global_dtors\"" ]

[]

[ "<s>", "rtx", "avr_return_addr_rtx", "(", "int", "count", ",", "rtx", "tem", ")", "{", "rtx", "r", ";", "if", "(", "count", ")", "return", "NULL", ";", "if", "(", "AVR_3_BYTE_PC", ")", "{", "r", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\".L__stack_usage+2\"", ")", ";", "warning", "(", "0", ",", "\"%<builtin_return_address%> contains only 2 bytes\"", "\" of address\"", ")", ";", "}", "else", "r", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\".L__stack_usage+1\"", ")", ";", "r", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tem", ",", "r", ")", ";", "r", "=", "gen_frame_mem", "(", "Pmode", ",", "memory_address", "(", "Pmode", ",", "r", ")", ")", ";", "r", "=", "gen_rtx_ROTATE", "(", "HImode", ",", "r", ",", "GEN_INT", "(", "8", ")", ")", ";", "return", "r", ";", "}", "</s>" ]

[ "Return", "contents", "of", "MEM", "at", "frame", "pointer", "+", "stack", "size", "+", "1", "(", "+2", "if", "3-byte", "PC", ")", ".", "This", "is", "return", "address", "of", "function", "." ]

[ "avr", "\".L__stack_usage+2\"", "0", "\"%<builtin_return_address%> contains only 2 bytes\"", "\" of address\"", "\".L__stack_usage+1\"", "8" ]

[]

[ "<s>", "int", "nios2_label_align", "(", "rtx", "label", ")", "{", "int", "n", "=", "CODE_LABEL_NUMBER", "(", "label", ")", ";", "if", "(", "label_align", "&&", "n", ">=", "min_labelno", "&&", "n", "<=", "max_labelno", ")", "return", "MAX", "(", "label_align", "[", "n", "-", "min_labelno", "]", ",", "align_labels", ".", "levels", "[", "0", "]", ".", "log", ")", ";", "return", "align_labels", ".", "levels", "[", "0", "]", ".", "log", ";", "}", "</s>" ]

[ "Implement", "LABEL_ALIGN", ",", "using", "the", "information", "gathered", "in", "nios2_reorg", "." ]

[ "nios2", "0", "0" ]

[]

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

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

[ "i386" ]

[]

[ "<s>", "bool", "SystemZTargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "if", "(", "!", "isInt", "<", "20", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "return", "AM", ".", "Scale", "==", "0", "||", "AM", ".", "Scale", "==", "1", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "20", "0", "1" ]

[]

[ "<s>", "bool", "Emitter", "<", "CodeEmitter", ">", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "II", "=", "(", "(", "AlphaTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getInstrInfo", "(", ")", ";", "do", "{", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "emitBasicBlock", "(", "*", "I", ")", ";", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha" ]

[]

[ "<s>", "void", "addPreEmitPass", "(", ")", "override", "{", "addPass", "(", "createJ2DelaySlotFillerPass", "(", "getJ2TargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createJ2ConstantIslandPass", "(", ")", ")", ";", "}", "</s>" ]

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

[ "J2", "J2", "J2", "J2" ]

[]

[ "<s>", "unsigned", "WebAssemblyFastISel", "::", "fastMaterializeAlloca", "(", "const", "AllocaInst", "*", "AI", ")", "{", "DenseMap", "<", "const", "AllocaInst", "*", ",", "int", ">", "::", "iterator", "SI", "=", "FuncInfo", ".", "StaticAllocaMap", ".", "find", "(", "AI", ")", ";", "if", "(", "SI", "!=", "FuncInfo", ".", "StaticAllocaMap", ".", "end", "(", ")", ")", "{", "unsigned", "ResultReg", "=", "createResultReg", "(", "Subtarget", "->", "hasAddr64", "(", ")", "?", "&", "WebAssembly", "::", "I64RegClass", ":", "&", "WebAssembly", "::", "I32RegClass", ")", ";", "unsigned", "Opc", "=", "Subtarget", "->", "hasAddr64", "(", ")", "?", "WebAssembly", "::", "COPY_I64", ":", "WebAssembly", "::", "COPY_I32", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ".", "addFrameIndex", "(", "SI", "->", "second", ")", ";", "return", "ResultReg", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Emit", "an", "alloca", "address", "in", "a", "register", "using", "target-specific", "logic", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly::I64RegClass", "WebAssembly::I32RegClass", "WebAssembly::COPY_I64", "WebAssembly::COPY_I32", "0" ]

[]

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

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

[ "R600" ]

[]

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

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

[ "MSP430", "MSP430", "0" ]

[]

[ "<s>", "TargetIRAnalysis", "WebAssemblyTargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "WebAssemblyTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetIRAnalysis", "appropriate", "for", "the", "target", "." ]

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

[]

[ "<s>", "bool", "X86AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", "==", "\".word\"", ")", "return", "ParseDirectiveWord", "(", "2", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".code\"", ")", ")", "return", "ParseDirectiveCode", "(", "IDVal", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".att_syntax\"", ")", ")", "{", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"prefix\"", ")", "Parser", ".", "Lex", "(", ")", ";", "else", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"noprefix\"", ")", "return", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "\"'.att_syntax noprefix' is not \"", "\"supported: registers must have a \"", "\"'%' prefix in .att_syntax\"", ")", ";", "}", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "0", ")", ";", "return", "false", ";", "}", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".intel_syntax\"", ")", ")", "{", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "1", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"noprefix\"", ")", "Parser", ".", "Lex", "(", ")", ";", "else", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"prefix\"", ")", "return", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "\"'.intel_syntax prefix' is not \"", "\"supported: registers must not have \"", "\"a '%' prefix in .intel_syntax\"", ")", ";", "}", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "\".word\"", "2", "\".code\"", "\".att_syntax\"", "\"prefix\"", "\"noprefix\"", "\"'.att_syntax noprefix' is not \"", "\"supported: registers must have a \"", "\"'%' prefix in .att_syntax\"", "0", "\".intel_syntax\"", "1", "\"noprefix\"", "\"prefix\"", "\"'.intel_syntax prefix' is not \"", "\"supported: registers must not have \"", "\"a '%' prefix in .intel_syntax\"" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MipsTargetStreamer", "&", "TS", "=", "getTargetStreamer", "(", ")", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "TS", ".", "forbidModuleDirective", "(", ")", ";", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "PrintDebugValueComment", "(", "MI", ",", "OS", ")", ";", "return", ";", "}", "if", "(", "MI", "->", "isDebugLabel", "(", ")", ")", "return", ";", "if", "(", "InConstantPool", "&&", "Opc", "!=", "Mips", "::", "CONSTPOOL_ENTRY", ")", "{", "OutStreamer", "->", "emitDataRegion", "(", "MCDR_DataRegionEnd", ")", ";", "InConstantPool", "=", "false", ";", "}", "if", "(", "Opc", "==", "Mips", "::", "CONSTPOOL_ENTRY", ")", "{", "unsigned", "LabelId", "=", "(", "unsigned", ")", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "unsigned", "CPIdx", "=", "(", "unsigned", ")", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "if", "(", "!", "InConstantPool", ")", "{", "OutStreamer", "->", "emitDataRegion", "(", "MCDR_DataRegion", ")", ";", "InConstantPool", "=", "true", ";", "}", "OutStreamer", "->", "emitLabel", "(", "GetCPISymbol", "(", "LabelId", ")", ")", ";", "const", "MachineConstantPoolEntry", "&", "MCPE", "=", "MCP", "->", "getConstants", "(", ")", "[", "CPIdx", "]", ";", "if", "(", "MCPE", ".", "isMachineConstantPoolEntry", "(", ")", ")", "emitMachineConstantPoolValue", "(", "MCPE", ".", "Val", ".", "MachineCPVal", ")", ";", "else", "emitGlobalConstant", "(", "MF", "->", "getDataLayout", "(", ")", ",", "MCPE", ".", "Val", ".", "ConstVal", ")", ";", "return", ";", "}", "switch", "(", "Opc", ")", "{", "case", "Mips", "::", "PATCHABLE_FUNCTION_ENTER", ":", "LowerPATCHABLE_FUNCTION_ENTER", "(", "*", "MI", ")", ";", "return", ";", "case", "Mips", "::", "PATCHABLE_FUNCTION_EXIT", ":", "LowerPATCHABLE_FUNCTION_EXIT", "(", "*", "MI", ")", ";", "return", ";", "case", "Mips", "::", "PATCHABLE_TAIL_CALL", ":", "LowerPATCHABLE_TAIL_CALL", "(", "*", "MI", ")", ";", "return", ";", "}", "if", "(", "EmitJalrReloc", "&&", "(", "MI", "->", "isReturn", "(", ")", "||", "MI", "->", "isCall", "(", ")", "||", "MI", "->", "isIndirectBranch", "(", ")", ")", ")", "{", "emitDirectiveRelocJalr", "(", "*", "MI", ",", "OutContext", ",", "TM", ",", "*", "OutStreamer", ",", "*", "Subtarget", ")", ";", "}", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", "->", "getIterator", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "do", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "&", "*", "I", ")", ")", "continue", ";", "if", "(", "I", "->", "isBundle", "(", ")", ")", "continue", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoReturn", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoReturn64", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoIndirectBranch", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoIndirectBranch64", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "TAILCALLREG", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "TAILCALLREG64", ")", "{", "emitPseudoIndirectBranch", "(", "*", "OutStreamer", ",", "&", "*", "I", ")", ";", "continue", ";", "}", "if", "(", "I", "->", "isPseudo", "(", ")", "&&", "!", "Subtarget", "->", "inMips16Mode", "(", ")", "&&", "!", "isLongBranchPseudo", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "llvm_unreachable", "(", "\"Pseudo opcode found in emitInstruction()\"", ")", ";", "MCInst", "TmpInst0", ";", "MCInstLowering", ".", "Lower", "(", "&", "*", "I", ",", "TmpInst0", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst0", ")", ";", "}", "while", "(", "(", "++", "I", "!=", "E", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "Mips", "Mips", "Mips", "128", "Mips::CONSTPOOL_ENTRY", "Mips::CONSTPOOL_ENTRY", "0", "1", "Mips::PATCHABLE_FUNCTION_ENTER", "Mips::PATCHABLE_FUNCTION_EXIT", "Mips::PATCHABLE_TAIL_CALL", "Mips::PseudoReturn", "Mips::PseudoReturn64", "Mips::PseudoIndirectBranch", "Mips::PseudoIndirectBranch64", "Mips::TAILCALLREG", "Mips::TAILCALLREG64", "Mips", "\"Pseudo opcode found in emitInstruction()\"" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "EVT", "VT", "=", "getValueType", "(", "Ty", ",", "true", ")", ";", "if", "(", "!", "isLegalAddressImmediate", "(", "AM", ".", "BaseOffs", ",", "VT", ",", "Subtarget", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "false", ";", "default", ":", "if", "(", "AM", ".", "BaseOffs", ")", "return", "false", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "if", "(", "Subtarget", "->", "isThumb2", "(", ")", ")", "return", "isLegalT2ScaledAddressingMode", "(", "AM", ",", "VT", ")", ";", "int", "Scale", "=", "AM", ".", "Scale", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "return", "false", ";", "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i32", ":", "if", "(", "Scale", "<", "0", ")", "Scale", "=", "-", "Scale", ";", "if", "(", "Scale", "==", "1", ")", "return", "true", ";", "return", "isPowerOf2_32", "(", "Scale", "&", "~", "1", ")", ";", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i64", ":", "if", "(", "(", "(", "unsigned", ")", "AM", ".", "HasBaseReg", "+", "Scale", ")", "<=", "2", ")", "return", "true", ";", "return", "false", ";", "case", "MVT", "::", "isVoid", ":", "if", "(", "Scale", "&", "1", ")", "return", "false", ";", "return", "isPowerOf2_32", "(", "Scale", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "1", "MVT::i1", "MVT::i8", "MVT::i32", "0", "1", "1", "MVT::i16", "MVT::i64", "2", "MVT::isVoid", "1" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "X86TargetMachine", "&", "TM", ",", "unsigned", "StackAlignOverride", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "X86ProcFamily", "(", "Others", ")", ",", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "TargetTriple", "(", "TT", ")", ",", "StackAlignOverride", "(", "StackAlignOverride", ")", ",", "In64BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", ",", "In32BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "!=", "Triple", "::", "CODE16", ")", ",", "In16BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "CODE16", ")", ",", "TSInfo", "(", "*", "TM", ".", "getDataLayout", "(", ")", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "FrameLowering", "(", "TargetFrameLowering", "::", "StackGrowsDown", ",", "getStackAlignment", "(", ")", ",", "is64Bit", "(", ")", "?", "-", "8", ":", "-", "4", ")", "{", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "{", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "is64Bit", "(", ")", ")", "{", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "}", "else", "if", "(", "isTargetCOFF", "(", ")", ")", "{", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "{", "assert", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", ";", "setPICStyle", "(", "PICStyles", "::", "StubDynamicNoPIC", ")", ";", "}", "}", "else", "if", "(", "isTargetELF", "(", ")", ")", "{", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addIRPasses", "(", ")", "{", "disablePass", "(", "&", "StackMapLivenessID", ")", ";", "disablePass", "(", "&", "FuncletLayoutID", ")", ";", "disablePass", "(", "&", "PatchableFunctionID", ")", ";", "addPass", "(", "createAMDGPULowerIntrinsicsPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUAlwaysInlinePass", "(", ")", ")", ";", "addPass", "(", "createAlwaysInlinerLegacyPass", "(", ")", ")", ";", "addPass", "(", "createBarrierNoopPass", "(", ")", ")", ";", "const", "AMDGPUTargetMachine", "&", "TM", "=", "getAMDGPUTargetMachine", "(", ")", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "{", "addPass", "(", "createAMDGPUCodeGenPreparePass", "(", "static_cast", "<", "const", "GCNTargetMachine", "*", ">", "(", "&", "TM", ")", ")", ")", ";", "}", "addPass", "(", "createAMDGPUOpenCLImageTypeLoweringPass", "(", ")", ")", ";", "if", "(", "TM", ".", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createInferAddressSpacesPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUPromoteAlloca", "(", "&", "TM", ")", ")", ";", "if", "(", "EnableSROA", ")", "addPass", "(", "createSROAPass", "(", ")", ")", ";", "addStraightLineScalarOptimizationPasses", "(", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addEarlyCSEOrGVNPass", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "thumb2_expand_return", "(", "bool", "simple_return", ")", "{", "int", "i", ",", "num_regs", ";", "unsigned", "long", "saved_regs_mask", ";", "arm_stack_offsets", "*", "offsets", ";", "offsets", "=", "arm_get_frame_offsets", "(", ")", ";", "saved_regs_mask", "=", "offsets", "->", "saved_regs_mask", ";", "for", "(", "i", "=", "0", ",", "num_regs", "=", "0", ";", "i", "<=", "LAST_ARM_REGNUM", ";", "i", "++", ")", "if", "(", "saved_regs_mask", "&", "(", "1", "<<", "i", ")", ")", "num_regs", "++", ";", "if", "(", "!", "simple_return", "&&", "saved_regs_mask", ")", "{", "if", "(", "num_regs", "==", "1", ")", "{", "rtx", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "2", ")", ")", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "PC_REGNUM", ")", ";", "rtx", "addr", "=", "gen_rtx_MEM", "(", "SImode", ",", "gen_rtx_POST_INC", "(", "SImode", ",", "stack_pointer_rtx", ")", ")", ";", "set_mem_alias_set", "(", "addr", ",", "get_frame_alias_set", "(", ")", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "0", ")", "=", "ret_rtx", ";", "XVECEXP", "(", "par", ",", "0", ",", "1", ")", "=", "gen_rtx_SET", "(", "reg", ",", "addr", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "par", ",", "0", ",", "1", ")", ")", "=", "1", ";", "emit_jump_insn", "(", "par", ")", ";", "}", "else", "{", "saved_regs_mask", "&=", "~", "(", "1", "<<", "LR_REGNUM", ")", ";", "saved_regs_mask", "|=", "(", "1", "<<", "PC_REGNUM", ")", ";", "arm_emit_multi_reg_pop", "(", "saved_regs_mask", ")", ";", "}", "}", "else", "{", "emit_jump_insn", "(", "simple_return_rtx", ")", ";", "}", "}", "</s>" ]

[ "Generate", "pattern", "*", "pop_multiple_with_stack_update_and_return", "if", "single", "POP", "instruction", "can", "be", "generated", ".", "LR", "should", "be", "replaced", "by", "PC", ".", "All", "the", "checks", "required", "are", "already", "done", "by", "USE_RETURN_INSN", "(", ")", ".", "Hence", ",", "all", "we", "really", "need", "to", "check", "here", "is", "if", "single", "register", "is", "to", "be", "returned", ",", "or", "multiple", "register", "return", "." ]

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

[]

[ "<s>", "const", "uint32_t", "*", "F2003fRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "return", "CSR_NoRegs_RegMask", ";", "}", "</s>" ]

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

[ "F2003f", "F2003f" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<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", "(", "llvm", "::", "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>", "static", "rtvec", "rs6000_const_vec", "(", "machine_mode", "mode", ")", "{", "int", "i", ",", "subparts", ";", "rtvec", "v", ";", "switch", "(", "mode", ")", "{", "case", "E_V1TImode", ":", "subparts", "=", "1", ";", "break", ";", "case", "E_V2DFmode", ":", "case", "E_V2DImode", ":", "subparts", "=", "2", ";", "break", ";", "case", "E_V4SFmode", ":", "case", "E_V4SImode", ":", "subparts", "=", "4", ";", "break", ";", "case", "E_V8HImode", ":", "subparts", "=", "8", ";", "break", ";", "case", "E_V16QImode", ":", "subparts", "=", "16", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "v", "=", "rtvec_alloc", "(", "subparts", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "subparts", "/", "2", ";", "++", "i", ")", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "gen_rtx_CONST_INT", "(", "DImode", ",", "i", "+", "subparts", "/", "2", ")", ";", "for", "(", "i", "=", "subparts", "/", "2", ";", "i", "<", "subparts", ";", "++", "i", ")", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "gen_rtx_CONST_INT", "(", "DImode", ",", "i", "-", "subparts", "/", "2", ")", ";", "return", "v", ";", "}", "</s>" ]

[ "Generate", "a", "vector", "of", "constants", "to", "permute", "MODE", "for", "a", "little-endian", "storage", "operation", "by", "swapping", "the", "two", "halves", "of", "a", "vector", "." ]

[ "powerpcspe", "1", "2", "4", "8", "16", "0", "2", "2", "2", "2" ]

[]

[ "<s>", "static", "void", "rs6000_define_or_undefine_macro", "(", "bool", "define_p", ",", "const", "char", "*", "name", ")", "{", "if", "(", "TARGET_DEBUG_BUILTIN", "||", "TARGET_DEBUG_TARGET", ")", "fprintf", "(", "stderr", ",", "\"#%s %s\\n\"", ",", "(", "define_p", ")", "?", "\"define\"", ":", "\"undef\"", ",", "name", ")", ";", "if", "(", "define_p", ")", "cpp_define", "(", "parse_in", ",", "name", ")", ";", "else", "cpp_undef", "(", "parse_in", ",", "name", ")", ";", "}", "</s>" ]

[ "Define", "or", "undefine", "a", "single", "macro", "." ]

[ "powerpcspe", "\"#%s %s\\n\"", "\"define\"", "\"undef\"" ]

[]

[ "<s>", "bool", "aarch64_float_const_representable_p", "(", "rtx", "x", ")", "{", "int", "point_pos", "=", "2", "*", "HOST_BITS_PER_WIDE_INT", "-", "1", ";", "int", "exponent", ";", "unsigned", "HOST_WIDE_INT", "mantissa", ",", "mask", ";", "REAL_VALUE_TYPE", "r", ",", "m", ";", "bool", "fail", ";", "if", "(", "!", "CONST_DOUBLE_P", "(", "x", ")", ")", "return", "false", ";", "if", "(", "GET_MODE", "(", "x", ")", "==", "VOIDmode", "||", "GET_MODE", "(", "x", ")", "==", "HFmode", ")", "return", "false", ";", "r", "=", "*", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ";", "if", "(", "REAL_VALUE_ISINF", "(", "r", ")", "||", "REAL_VALUE_ISNAN", "(", "r", ")", "||", "REAL_VALUE_MINUS_ZERO", "(", "r", ")", ")", "return", "false", ";", "r", "=", "real_value_abs", "(", "&", "r", ")", ";", "exponent", "=", "REAL_EXP", "(", "&", "r", ")", ";", "real_ldexp", "(", "&", "m", ",", "&", "r", ",", "point_pos", "-", "exponent", ")", ";", "wide_int", "w", "=", "real_to_integer", "(", "&", "m", ",", "&", "fail", ",", "HOST_BITS_PER_WIDE_INT", "*", "2", ")", ";", "if", "(", "w", ".", "elt", "(", "0", ")", "!=", "0", ")", "return", "false", ";", "mantissa", "=", "w", ".", "elt", "(", "1", ")", ";", "point_pos", "-=", "HOST_BITS_PER_WIDE_INT", ";", "mask", "=", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "(", "point_pos", "-", "5", ")", ")", "-", "1", ";", "if", "(", "(", "mantissa", "&", "mask", ")", "!=", "0", ")", "return", "false", ";", "mantissa", ">>=", "point_pos", "-", "5", ";", "if", "(", "mantissa", "==", "0", ")", "return", "false", ";", "mantissa", "&=", "~", "(", "1", "<<", "4", ")", ";", "gcc_assert", "(", "mantissa", "<=", "15", ")", ";", "exponent", "=", "5", "-", "exponent", ";", "return", "(", "exponent", ">=", "0", "&&", "exponent", "<=", "7", ")", ";", "}", "</s>" ]

[ "Return", "true", "iff", "X", "can", "be", "represented", "by", "a", "quarter-precision", "floating", "point", "immediate", "operand", "X", ".", "Note", ",", "we", "can", "not", "represent", "0.0", "." ]

[ "aarch64", "2", "1", "2", "0", "0", "1", "1", "5", "1", "0", "5", "0", "1", "4", "15", "5", "0", "7" ]

[]

[ "<s>", "std", "::", "unique_ptr", "<", "MCObjectWriter", ">", "AVRAsmBackend", "::", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "{", "return", "createAVRELFObjectWriter", "(", "OS", ",", "MCELFObjectTargetWriter", "::", "getOSABI", "(", "OSType", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AGCAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "switch", "(", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown match type detected!\"", ")", ";", "case", "Match_IgnoredExtend", ":", "return", "false", ";", "case", "Match_Success", ":", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"unrecognized instruction mnemonic\"", ")", ";", "case", "Match_ExtracodeFail", ":", "return", "Error", "(", "IDLoc", ",", "\"extracode instruction should be prefixed with EXTEND\"", ")", ";", "case", "Match_NonExtracodeFail", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction prefixed with EXTEND is not an extracode\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "ErrorLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "Operands", "[", "ErrorInfo", "]", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_InvalidMem12", ":", "{", "SMLoc", "ErrorLoc", "=", "Operands", "[", "ErrorInfo", "]", "->", "getStartLoc", "(", ")", ";", "return", "Error", "(", "ErrorLoc", ",", "\"memory address must be an immediate in the range \"", "\"[0, 4095] or a symbol\"", ")", ";", "}", "case", "Match_InvalidMem10", ":", "{", "SMLoc", "ErrorLoc", "=", "Operands", "[", "ErrorInfo", "]", "->", "getStartLoc", "(", ")", ";", "return", "Error", "(", "ErrorLoc", ",", "\"memory address must be an immediate in the range \"", "\"[0, 1023] or a symbol\"", ")", ";", "}", "case", "Match_InvalidIO9", ":", "{", "SMLoc", "ErrorLoc", "=", "Operands", "[", "ErrorInfo", "]", "->", "getStartLoc", "(", ")", ";", "return", "Error", "(", "ErrorLoc", ",", "\"IO channel address must be an immediate in the \"", "\"range [0, 511] or a symbol\"", ")", ";", "}", "case", "Match_InvalidAddress12", ":", "{", "SMLoc", "ErrorLoc", "=", "Operands", "[", "ErrorInfo", "]", "->", "getStartLoc", "(", ")", ";", "return", "Error", "(", "ErrorLoc", ",", "\"address must be an immediate in the range [0, 4095] or a symbol\"", ")", ";", "}", "case", "Match_InvalidBank6", ":", "{", "SMLoc", "ErrorLoc", "=", "Operands", "[", "ErrorInfo", "]", "->", "getStartLoc", "(", ")", ";", "return", "Error", "(", "ErrorLoc", ",", "\"bank number must be an immediate in the range [0, 35]\"", ")", ";", "}", "case", "Match_InvalidBlock2", ":", "{", "SMLoc", "ErrorLoc", "=", "Operands", "[", "ErrorInfo", "]", "->", "getStartLoc", "(", ")", ";", "return", "Error", "(", "ErrorLoc", ",", "\"block number must be either 0, 2 or 3\"", ")", ";", "}", "case", "Match_InvalidImm15", ":", "{", "SMLoc", "ErrorLoc", "=", "Operands", "[", "ErrorInfo", "]", "->", "getStartLoc", "(", ")", ";", "return", "Error", "(", "ErrorLoc", ",", "\"operand must be an immediate in the range [0, 32767] or a symbol\"", ")", ";", "}", "}", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "AGC", "AGC", "\"Unknown match type detected!\"", "\"unrecognized instruction mnemonic\"", "\"extracode instruction should be prefixed with EXTEND\"", "\"instruction prefixed with EXTEND is not an extracode\"", "0U", "\"too few operands for instruction\"", "\"invalid operand for instruction\"", "\"memory address must be an immediate in the range \"", "\"[0, 4095] or a symbol\"", "\"memory address must be an immediate in the range \"", "\"[0, 1023] or a symbol\"", "\"IO channel address must be an immediate in the \"", "\"range [0, 511] or a symbol\"", "\"address must be an immediate in the range [0, 4095] or a symbol\"", "\"bank number must be an immediate in the range [0, 35]\"", "\"block number must be either 0, 2 or 3\"", "\"operand must be an immediate in the range [0, 32767] or a symbol\"" ]

[]

[ "<s>", "int", "riscv_address_insns", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "bool", "might_split_p", ")", "{", "struct", "riscv_address_info", "addr", ";", "int", "n", "=", "1", ";", "if", "(", "!", "riscv_classify_address", "(", "&", "addr", ",", "x", ",", "mode", ",", "false", ")", ")", "return", "0", ";", "if", "(", "mode", "!=", "BLKmode", "&&", "might_split_p", ")", "n", "+=", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "if", "(", "addr", ".", "type", "==", "ADDRESS_LO_SUM", ")", "n", "+=", "riscv_symbol_insns", "(", "addr", ".", "symbol_type", ")", "-", "1", ";", "return", "n", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "needed", "to", "load", "or", "store", "a", "value", "of", "mode", "MODE", "at", "address", "X", ".", "Return", "0", "if", "X", "is", "n't", "valid", "for", "MODE", ".", "Assume", "that", "multiword", "moves", "may", "need", "to", "be", "split", "into", "word", "moves", "if", "MIGHT_SPLIT_P", ",", "otherwise", "assume", "that", "a", "single", "load", "or", "store", "is", "enough", "." ]

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

[]

[ "<s>", "static", "void", "dump_target_flag_bits", "(", "const", "int", "flags", ")", "{", "if", "(", "flags", "&", "MASK_64BIT", ")", "fprintf", "(", "stderr", ",", "\"64BIT \"", ")", ";", "if", "(", "flags", "&", "MASK_APP_REGS", ")", "fprintf", "(", "stderr", ",", "\"APP_REGS \"", ")", ";", "if", "(", "flags", "&", "MASK_FASTER_STRUCTS", ")", "fprintf", "(", "stderr", ",", "\"FASTER_STRUCTS \"", ")", ";", "if", "(", "flags", "&", "MASK_FLAT", ")", "fprintf", "(", "stderr", ",", "\"FLAT \"", ")", ";", "if", "(", "flags", "&", "MASK_FMAF", ")", "fprintf", "(", "stderr", ",", "\"FMAF \"", ")", ";", "if", "(", "flags", "&", "MASK_FPU", ")", "fprintf", "(", "stderr", ",", "\"FPU \"", ")", ";", "if", "(", "flags", "&", "MASK_HARD_QUAD", ")", "fprintf", "(", "stderr", ",", "\"HARD_QUAD \"", ")", ";", "if", "(", "flags", "&", "MASK_POPC", ")", "fprintf", "(", "stderr", ",", "\"POPC \"", ")", ";", "if", "(", "flags", "&", "MASK_PTR64", ")", "fprintf", "(", "stderr", ",", "\"PTR64 \"", ")", ";", "if", "(", "flags", "&", "MASK_STACK_BIAS", ")", "fprintf", "(", "stderr", ",", "\"STACK_BIAS \"", ")", ";", "if", "(", "flags", "&", "MASK_UNALIGNED_DOUBLES", ")", "fprintf", "(", "stderr", ",", "\"UNALIGNED_DOUBLES \"", ")", ";", "if", "(", "flags", "&", "MASK_V8PLUS", ")", "fprintf", "(", "stderr", ",", "\"V8PLUS \"", ")", ";", "if", "(", "flags", "&", "MASK_VIS", ")", "fprintf", "(", "stderr", ",", "\"VIS \"", ")", ";", "if", "(", "flags", "&", "MASK_VIS2", ")", "fprintf", "(", "stderr", ",", "\"VIS2 \"", ")", ";", "if", "(", "flags", "&", "MASK_VIS3", ")", "fprintf", "(", "stderr", ",", "\"VIS3 \"", ")", ";", "if", "(", "flags", "&", "MASK_VIS4", ")", "fprintf", "(", "stderr", ",", "\"VIS4 \"", ")", ";", "if", "(", "flags", "&", "MASK_CBCOND", ")", "fprintf", "(", "stderr", ",", "\"CBCOND \"", ")", ";", "if", "(", "flags", "&", "MASK_DEPRECATED_V8_INSNS", ")", "fprintf", "(", "stderr", ",", "\"DEPRECATED_V8_INSNS \"", ")", ";", "if", "(", "flags", "&", "MASK_SPARCLET", ")", "fprintf", "(", "stderr", ",", "\"SPARCLET \"", ")", ";", "if", "(", "flags", "&", "MASK_SPARCLITE", ")", "fprintf", "(", "stderr", ",", "\"SPARCLITE \"", ")", ";", "if", "(", "flags", "&", "MASK_V8", ")", "fprintf", "(", "stderr", ",", "\"V8 \"", ")", ";", "if", "(", "flags", "&", "MASK_V9", ")", "fprintf", "(", "stderr", ",", "\"V9 \"", ")", ";", "}", "</s>" ]

[ "Helpers", "for", "TARGET_DEBUG_OPTIONS", "." ]

[ "sparc", "\"64BIT \"", "\"APP_REGS \"", "\"FASTER_STRUCTS \"", "\"FLAT \"", "\"FMAF \"", "\"FPU \"", "\"HARD_QUAD \"", "\"POPC \"", "\"PTR64 \"", "\"STACK_BIAS \"", "\"UNALIGNED_DOUBLES \"", "\"V8PLUS \"", "\"VIS \"", "\"VIS2 \"", "\"VIS3 \"", "\"VIS4 \"", "\"CBCOND \"", "\"DEPRECATED_V8_INSNS \"", "\"SPARCLET \"", "\"SPARCLITE \"", "\"V8 \"", "\"V9 \"" ]

[]

[ "<s>", "bool", "AArch64StorePairSuppress", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "TargetSubtargetInfo", "&", "ST", "=", "MF", ".", "getSubtarget", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "SchedModel", ".", "init", "(", "&", "ST", ")", ";", "Traces", "=", "&", "getAnalysis", "<", "MachineTraceMetrics", ">", "(", ")", ";", "MinInstr", "=", "nullptr", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** \"", "<<", "getPassName", "(", ")", "<<", "\": \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "!", "SchedModel", ".", "hasInstrSchedModel", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" Skipping pass: no machine model present.\\n\"", ")", ";", "return", "false", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "bool", "SuppressSTP", "=", "false", ";", "unsigned", "PrevBaseReg", "=", "0", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "isNarrowFPStore", "(", "MI", ")", ")", "continue", ";", "const", "MachineOperand", "*", "BaseOp", ";", "int64_t", "Offset", ";", "bool", "OffsetIsScalable", ";", "if", "(", "TII", "->", "getMemOperandWithOffset", "(", "MI", ",", "BaseOp", ",", "Offset", ",", "OffsetIsScalable", ",", "TRI", ")", "&&", "BaseOp", "->", "isReg", "(", ")", ")", "{", "Register", "BaseReg", "=", "BaseOp", "->", "getReg", "(", ")", ";", "if", "(", "PrevBaseReg", "==", "BaseReg", ")", "{", "if", "(", "!", "SuppressSTP", "&&", "shouldAddSTPToBlock", "(", "MI", ".", "getParent", "(", ")", ")", ")", "break", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Unpairing store \"", "<<", "MI", "<<", "\"\\n\"", ")", ";", "SuppressSTP", "=", "true", ";", "TII", "->", "suppressLdStPair", "(", "MI", ")", ";", "}", "PrevBaseReg", "=", "BaseReg", ";", "}", "else", "PrevBaseReg", "=", "0", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"*** \"", "\": \"", "\" Skipping pass: no machine model present.\\n\"", "0", "\"Unpairing store \"", "\"\\n\"", "0" ]

[]

[ "<s>", "const", "char", "*", "output_fp_compare", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ",", "bool", "eflags_p", ",", "bool", "unordered_p", ")", "{", "rtx", "*", "xops", "=", "eflags_p", "?", "&", "operands", "[", "0", "]", ":", "&", "operands", "[", "1", "]", ";", "bool", "stack_top_dies", ";", "static", "char", "buf", "[", "40", "]", ";", "const", "char", "*", "p", ";", "gcc_assert", "(", "STACK_TOP_P", "(", "xops", "[", "0", "]", ")", ")", ";", "stack_top_dies", "=", "find_regno_note", "(", "insn", ",", "REG_DEAD", ",", "FIRST_STACK_REG", ")", ";", "if", "(", "eflags_p", ")", "{", "p", "=", "unordered_p", "?", "\"fucomi\"", ":", "\"fcomi\"", ";", "strcpy", "(", "buf", ",", "p", ")", ";", "p", "=", "\"p\\t{%y1, %0|%0, %y1}\"", ";", "strcat", "(", "buf", ",", "p", "+", "!", "stack_top_dies", ")", ";", "return", "buf", ";", "}", "if", "(", "STACK_REG_P", "(", "xops", "[", "1", "]", ")", "&&", "stack_top_dies", "&&", "find_regno_note", "(", "insn", ",", "REG_DEAD", ",", "FIRST_STACK_REG", "+", "1", ")", ")", "{", "gcc_assert", "(", "REGNO", "(", "xops", "[", "1", "]", ")", "==", "FIRST_STACK_REG", "+", "1", ")", ";", "p", "=", "unordered_p", "?", "\"fucompp\"", ":", "\"fcompp\"", ";", "strcpy", "(", "buf", ",", "p", ")", ";", "}", "else", "if", "(", "const0_operand", "(", "xops", "[", "1", "]", ",", "VOIDmode", ")", ")", "{", "gcc_assert", "(", "!", "unordered_p", ")", ";", "strcpy", "(", "buf", ",", "\"ftst\"", ")", ";", "}", "else", "{", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "xops", "[", "1", "]", ")", ")", "==", "MODE_INT", ")", "{", "gcc_assert", "(", "!", "unordered_p", ")", ";", "p", "=", "\"ficom\"", ";", "}", "else", "p", "=", "unordered_p", "?", "\"fucom\"", ":", "\"fcom\"", ";", "strcpy", "(", "buf", ",", "p", ")", ";", "p", "=", "\"p%Z2\\t%y2\"", ";", "strcat", "(", "buf", ",", "p", "+", "!", "stack_top_dies", ")", ";", "}", "output_asm_insn", "(", "buf", ",", "operands", ")", ";", "return", "\"fnstsw\\t%0\"", ";", "}", "</s>" ]

[ "Output", "code", "for", "INSN", "to", "compare", "OPERANDS", ".", "EFLAGS_P", "is", "1", "when", "fcomi", "should", "be", "used", "and", "2", "when", "fnstsw", "should", "be", "used", ".", "UNORDERED_P", "is", "true", "when", "fucom", "should", "be", "used", "." ]

[ "i386", "0", "1", "40", "0", "\"fucomi\"", "\"fcomi\"", "\"p\\t{%y1, %0|%0, %y1}\"", "1", "1", "1", "1", "\"fucompp\"", "\"fcompp\"", "1", "\"ftst\"", "1", "\"ficom\"", "\"fucom\"", "\"fcom\"", "\"p%Z2\\t%y2\"", "\"fnstsw\\t%0\"" ]

[]

[ "<s>", "uint64_t", "getReturnSaveOffset", "(", ")", "const", "{", "return", "ReturnSaveOffset", ";", "}", "</s>" ]

[ "getReturnSaveOffset", "-", "Return", "the", "previous", "frame", "offset", "to", "save", "the", "return", "address", "." ]

[ "PowerPC" ]

[]

[ "<s>", "unsigned", "getScalarizationOverhead", "(", "Type", "*", "Ty", ",", "bool", "Insert", ",", "bool", "Extract", ")", "{", "return", "0", ";", "}", "</s>" ]

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

[ "Hexagon", "0" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "AdjustInstrPostInstrSelection", "(", "MachineInstr", "*", "MI", ",", "SDNode", "*", "Node", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "!", "TII", "->", "isMIMG", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", ";", "unsigned", "VReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "Writemask", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "BitsSet", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "4", ";", "++", "i", ")", "BitsSet", "+=", "Writemask", "&", "(", "1", "<<", "i", ")", "?", "1", ":", "0", ";", "const", "TargetRegisterClass", "*", "RC", ";", "switch", "(", "BitsSet", ")", "{", "default", ":", "return", ";", "case", "1", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_32RegClass", ";", "break", ";", "case", "2", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_64RegClass", ";", "break", ";", "case", "3", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_96RegClass", ";", "break", ";", "}", "unsigned", "NewOpcode", "=", "TII", "->", "getMaskedMIMGOp", "(", "MI", "->", "getOpcode", "(", ")", ",", "BitsSet", ")", ";", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "NewOpcode", ")", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "setRegClass", "(", "VReg", ",", "RC", ")", ";", "}", "</s>" ]

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

[ "R600", "SI", "SI", "SI", "0", "1", "0", "0", "4", "1", "1", "0", "1", "2", "3" ]

[]

[ "<s>", "static", "bool", "mips_direct_save_slot_move_p", "(", "unsigned", "int", "regno", ",", "rtx", "mem", ",", "bool", "load_p", ")", "{", "if", "(", "TARGET_MIPS16", "&&", "!", "load_p", "&&", "regno", "==", "RETURN_ADDR_REGNUM", ")", "return", "false", ";", "return", "mips_secondary_reload_class", "(", "REGNO_REG_CLASS", "(", "regno", ")", ",", "GET_MODE", "(", "mem", ")", ",", "mem", ",", "load_p", ")", "==", "NO_REGS", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "move", "between", "register", "REGNO", "and", "its", "save", "slot", "(", "MEM", ")", "can", "be", "done", "in", "a", "single", "move", ".", "LOAD_P", "is", "true", "if", "we", "are", "loading", "from", "the", "slot", ",", "false", "if", "we", "are", "storing", "to", "it", "." ]

[ "mips" ]

[]

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

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

[ "ARM64", "ARM64" ]

[]

[ "<s>", "void", "MipsSEInstrInfo", "::", "adjustStackPtr", "(", "unsigned", "SP", ",", "int64_t", "Amount", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "MipsSubtarget", "&", "STI", "=", "Subtarget", ";", "DebugLoc", "DL", "=", "I", "!=", "MBB", ".", "end", "(", ")", "?", "I", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "unsigned", "ADDu", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "DADDu", ":", "Mips", "::", "ADDu", ";", "unsigned", "ADDiu", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "DADDiu", ":", "Mips", "::", "ADDiu", ";", "if", "(", "isInt", "<", "16", ">", "(", "Amount", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ADDiu", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "else", "{", "unsigned", "Reg", "=", "loadImmediate", "(", "Amount", ",", "MBB", ",", "I", ",", "DL", ",", "nullptr", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ADDu", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "</s>" ]

[ "Adjust", "SP", "by", "Amount", "bytes", "." ]

[ "Mips", "Mips", "Mips", "Mips::DADDu", "Mips::ADDu", "Mips::DADDiu", "Mips::ADDiu", "16" ]

[]

[ "<s>", "static", "bool", "is_va_list_char_pointer", "(", "tree", "type", ")", "{", "tree", "canonic", ";", "if", "(", "!", "TARGET_64BIT", ")", "return", "true", ";", "canonic", "=", "ix86_canonical_va_list_type", "(", "type", ")", ";", "return", "(", "canonic", "==", "ms_va_list_type_node", "||", "(", "ix86_abi", "==", "MS_ABI", "&&", "canonic", "==", "va_list_type_node", ")", ")", ";", "}", "</s>" ]

[ "Checks", "if", "TYPE", "is", "of", "kind", "va_list", "char", "*", "." ]

[ "i386" ]

[]

[ "<s>", "static", "rtx", "function_arg_vector_value", "(", "int", "size", ",", "enum", "machine_mode", "base_mode", ",", "int", "regno", ")", "{", "unsigned", "short", "base_mode_size", "=", "GET_MODE_SIZE", "(", "base_mode", ")", ";", "int", "nregs", "=", "size", "/", "base_mode_size", ",", "i", ";", "rtx", "regs", ";", "regs", "=", "gen_rtx_PARALLEL", "(", "BLKmode", ",", "rtvec_alloc", "(", "nregs", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nregs", ";", "i", "++", ")", "{", "XVECEXP", "(", "regs", ",", "0", ",", "i", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "base_mode", ",", "regno", ")", ",", "GEN_INT", "(", "base_mode_size", "*", "i", ")", ")", ";", "regno", "+=", "base_mode_size", "/", "4", ";", "}", "return", "regs", ";", "}", "</s>" ]

[ "Used", "by", "function_arg", "and", "sparc_function_value_1", "to", "implement", "the", "conventions", "for", "passing", "and", "returning", "BLKmode", "vectors", ".", "Return", "an", "expression", "valid", "as", "a", "return", "value", "for", "the", "FUNCTION_ARG", "and", "TARGET_FUNCTION_VALUE", ".", "SIZE", "is", "the", "size", "in", "bytes", "of", "the", "vector", ".", "REGNO", "is", "the", "FP", "hard", "register", "the", "vector", "will", "be", "passed", "in", "." ]

[ "sparc", "0", "0", "4" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Hexagon", "::", "S2_storerb_io", ":", "case", "Hexagon", "::", "S2_storerh_io", ":", "case", "Hexagon", "::", "S2_storeri_io", ":", "case", "Hexagon", "::", "S2_storerd_io", ":", "case", "Hexagon", "::", "V6_vS32b_ai", ":", "case", "Hexagon", "::", "V6_vS32Ub_ai", ":", "case", "Hexagon", "::", "STriw_pred", ":", "case", "Hexagon", "::", "STriw_ctr", ":", "case", "Hexagon", "::", "PS_vstorerq_ai", ":", "case", "Hexagon", "::", "PS_vstorerw_ai", ":", "{", "const", "MachineOperand", "&", "OpFI", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "if", "(", "!", "OpFI", ".", "isFI", "(", ")", ")", "return", "0", ";", "const", "MachineOperand", "&", "OpOff", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "if", "(", "!", "OpOff", ".", "isImm", "(", ")", "||", "OpOff", ".", "getImm", "(", ")", "!=", "0", ")", "return", "0", ";", "FrameIndex", "=", "OpFI", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "case", "Hexagon", "::", "S2_pstorerbt_io", ":", "case", "Hexagon", "::", "S2_pstorerbf_io", ":", "case", "Hexagon", "::", "S2_pstorerht_io", ":", "case", "Hexagon", "::", "S2_pstorerhf_io", ":", "case", "Hexagon", "::", "S2_pstorerit_io", ":", "case", "Hexagon", "::", "S2_pstorerif_io", ":", "case", "Hexagon", "::", "S2_pstorerdt_io", ":", "case", "Hexagon", "::", "S2_pstorerdf_io", ":", "{", "const", "MachineOperand", "&", "OpFI", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "if", "(", "!", "OpFI", ".", "isFI", "(", ")", ")", "return", "0", ";", "const", "MachineOperand", "&", "OpOff", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "!", "OpOff", ".", "isImm", "(", ")", "||", "OpOff", ".", "getImm", "(", ")", "!=", "0", ")", "return", "0", ";", "FrameIndex", "=", "OpFI", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::S2_storerb_io", "Hexagon::S2_storerh_io", "Hexagon::S2_storeri_io", "Hexagon::S2_storerd_io", "Hexagon::V6_vS32b_ai", "Hexagon::V6_vS32Ub_ai", "Hexagon::STriw_pred", "Hexagon::STriw_ctr", "Hexagon::PS_vstorerq_ai", "Hexagon::PS_vstorerw_ai", "0", "0", "1", "0", "0", "2", "Hexagon::S2_pstorerbt_io", "Hexagon::S2_pstorerbf_io", "Hexagon::S2_pstorerht_io", "Hexagon::S2_pstorerhf_io", "Hexagon::S2_pstorerit_io", "Hexagon::S2_pstorerif_io", "Hexagon::S2_pstorerdt_io", "Hexagon::S2_pstorerdf_io", "1", "0", "2", "0", "0", "3", "0" ]

[]

[ "<s>", "static", "unsigned", "int", "pa_section_type_flags", "(", "tree", "decl", ",", "const", "char", "*", "name", ",", "int", "reloc", ")", "{", "unsigned", "int", "flags", ";", "flags", "=", "default_section_type_flags", "(", "decl", ",", "name", ",", "reloc", ")", ";", "if", "(", "strcmp", "(", "name", ",", "\".data.rel.ro\"", ")", "==", "0", "||", "strcmp", "(", "name", ",", "\".data.rel.ro.local\"", ")", "==", "0", ")", "flags", "|=", "SECTION_WRITE", "|", "SECTION_RELRO", ";", "return", "flags", ";", "}", "</s>" ]

[ "Implement", "TARGET_SECTION_TYPE_FLAGS", "." ]

[ "pa", "\".data.rel.ro\"", "0", "\".data.rel.ro.local\"", "0" ]

[]

[ "<s>", "static", "bool", "already_warned", "(", "tree", "fndecl", ")", "{", "struct", "decl_chain", "*", "warned", ";", "for", "(", "warned", "=", "warned_decls", ";", "warned", "!=", "NULL", ";", "warned", "=", "warned", "->", "next", ")", "if", "(", "warned", "->", "fndecl", "==", "fndecl", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "TRUE", "if", "FNDECL", "is", "on", "our", "list", "of", "warned", "about", "decls", "." ]

[ "rx" ]

[]

[ "<s>", "void", "TMS320C64XInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "const", "bool", "destGPR", "=", "TMS320C64X", "::", "GPRegsRegClass", ".", "contains", "(", "DestReg", ")", ";", "const", "bool", "srcGPR", "=", "TMS320C64X", "::", "GPRegsRegClass", ".", "contains", "(", "SrcReg", ")", ";", "if", "(", "destGPR", "&&", "srcGPR", ")", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "TMS320C64X", "::", "mv", ")", ",", "DestReg", ")", ";", "MIB", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "addDefaultPred", "(", "MIB", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "\"Can not copy physical registers!\"", ")", ";", "}", "</s>" ]

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

[ "TMS320C64X", "TMS320C64X", "TMS320C64X::GPRegsRegClass", "TMS320C64X::GPRegsRegClass", "TMS320C64X::mv", "\"Can not copy physical registers!\"" ]

[]

[ "<s>", "static", "void", "aarch64_expand_sve_const_vector", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "src", ")", ";", "unsigned", "int", "npatterns", "=", "CONST_VECTOR_NPATTERNS", "(", "src", ")", ";", "unsigned", "int", "nelts_per_pattern", "=", "CONST_VECTOR_NELTS_PER_PATTERN", "(", "src", ")", ";", "gcc_assert", "(", "npatterns", ">", "1", ")", ";", "if", "(", "nelts_per_pattern", "==", "1", ")", "{", "scalar_int_mode", "int_mode", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "int_mode", "=", "TImode", ";", "else", "{", "unsigned", "int", "int_bits", "=", "GET_MODE_UNIT_BITSIZE", "(", "mode", ")", "*", "npatterns", ";", "gcc_assert", "(", "int_bits", "<=", "128", ")", ";", "int_mode", "=", "int_mode_for_size", "(", "int_bits", ",", "0", ")", ".", "require", "(", ")", ";", "}", "rtx", "int_value", "=", "simplify_gen_subreg", "(", "int_mode", ",", "src", ",", "mode", ",", "0", ")", ";", "if", "(", "int_value", "&&", "aarch64_expand_sve_widened_duplicate", "(", "dest", ",", "int_mode", ",", "int_value", ")", ")", "return", ";", "}", "rtx_vector_builder", "builder", ";", "auto_vec", "<", "rtx", ",", "16", ">", "vectors", "(", "npatterns", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "npatterns", ";", "++", "i", ")", "{", "builder", ".", "new_vector", "(", "mode", ",", "1", ",", "nelts_per_pattern", ")", ";", "for", "(", "unsigned", "int", "j", "=", "0", ";", "j", "<", "nelts_per_pattern", ";", "++", "j", ")", "builder", ".", "quick_push", "(", "CONST_VECTOR_ELT", "(", "src", ",", "i", "+", "j", "*", "npatterns", ")", ")", ";", "vectors", ".", "quick_push", "(", "force_reg", "(", "mode", ",", "builder", ".", "build", "(", ")", ")", ")", ";", "}", "while", "(", "npatterns", ">", "1", ")", "{", "npatterns", "/=", "2", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "npatterns", ";", "++", "i", ")", "{", "rtx", "tmp", "=", "(", "npatterns", "==", "1", "?", "dest", ":", "gen_reg_rtx", "(", "mode", ")", ")", ";", "rtvec", "v", "=", "gen_rtvec", "(", "2", ",", "vectors", "[", "i", "]", ",", "vectors", "[", "i", "+", "npatterns", "]", ")", ";", "emit_set_insn", "(", "tmp", ",", "gen_rtx_UNSPEC", "(", "mode", ",", "v", ",", "UNSPEC_ZIP1", ")", ")", ";", "vectors", "[", "i", "]", "=", "tmp", ";", "}", "}", "gcc_assert", "(", "vectors", "[", "0", "]", "==", "dest", ")", ";", "}", "</s>" ]

[ "Expand", "a", "move", "of", "general", "CONST_VECTOR", "SRC", "into", "DEST", ",", "given", "that", "it", "is", "n't", "a", "simple", "duplicate", "or", "series", "." ]

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

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Hexagon", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "HexagonISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "HexagonISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "ISD::OutputArg", "16", "Hexagon", "0", "0", "1", "HexagonISD::RET_FLAG", "MVT::Other", "HexagonISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "bool", "ARMConstantIslands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MachineConstantPool", "&", "MCP", "=", "*", "MF", ".", "getConstantPool", "(", ")", ";", "TII", "=", "(", "const", "ARMInstrInfo", "*", ")", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "STI", "=", "&", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "isThumb", "=", "AFI", "->", "isThumbFunction", "(", ")", ";", "isThumb1", "=", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ";", "isThumb2", "=", "AFI", "->", "isThumb2Function", "(", ")", ";", "HasFarJump", "=", "false", ";", "HasInlineAsm", "=", "false", ";", "MF", ".", "RenumberBlocks", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "if", "(", "isThumb2", "&&", "AdjustJumpTableBlocks", ")", "{", "JumpTableFunctionScan", "(", "MF", ")", ";", "MadeChange", "|=", "ReorderThumb2JumpTables", "(", "MF", ")", ";", "T2JumpTables", ".", "clear", "(", ")", ";", "MF", ".", "RenumberBlocks", "(", ")", ";", "}", "if", "(", "!", "isThumb1", ")", "MF", ".", "EnsureAlignment", "(", "2", ")", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "CPEMIs", ";", "if", "(", "!", "MCP", ".", "isEmpty", "(", ")", ")", "{", "DoInitialPlacement", "(", "MF", ",", "CPEMIs", ")", ";", "if", "(", "isThumb1", ")", "MF", ".", "EnsureAlignment", "(", "2", ")", ";", "}", "AFI", "->", "initConstPoolEntryUId", "(", "CPEMIs", ".", "size", "(", ")", ")", ";", "InitialFunctionScan", "(", "MF", ",", "CPEMIs", ")", ";", "CPEMIs", ".", "clear", "(", ")", ";", "DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "RemoveUnusedCPEntries", "(", ")", ";", "unsigned", "NoCPIters", "=", "0", ",", "NoBRIters", "=", "0", ";", "while", "(", "true", ")", "{", "bool", "CPChange", "=", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CPUsers", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "CPChange", "|=", "HandleConstantPoolUser", "(", "MF", ",", "i", ")", ";", "if", "(", "CPChange", "&&", "++", "NoCPIters", ">", "30", ")", "llvm_unreachable", "(", "\"Constant Island pass failed to converge!\"", ")", ";", "DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "NewWaterList", ".", "clear", "(", ")", ";", "bool", "BRChange", "=", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ImmBranches", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BRChange", "|=", "FixUpImmediateBr", "(", "MF", ",", "ImmBranches", "[", "i", "]", ")", ";", "if", "(", "BRChange", "&&", "++", "NoBRIters", ">", "30", ")", "llvm_unreachable", "(", "\"Branch Fix Up pass failed to converge!\"", ")", ";", "DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "if", "(", "!", "CPChange", "&&", "!", "BRChange", ")", "break", ";", "MadeChange", "=", "true", ";", "}", "if", "(", "isThumb2", "&&", "!", "STI", "->", "prefers32BitThumb", "(", ")", ")", "MadeChange", "|=", "OptimizeThumb2Instructions", "(", "MF", ")", ";", "verify", "(", "MF", ")", ";", "if", "(", "isThumb", "&&", "!", "HasFarJump", "&&", "AFI", "->", "isLRSpilledForFarJump", "(", ")", ")", "MadeChange", "|=", "UndoLRSpillRestore", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "'\\n'", ";", "dumpBBs", "(", ")", ")", ";", "BBSizes", ".", "clear", "(", ")", ";", "BBOffsets", ".", "clear", "(", ")", ";", "WaterList", ".", "clear", "(", ")", ";", "CPUsers", ".", "clear", "(", ")", ";", "CPEntries", ".", "clear", "(", ")", ";", "ImmBranches", ".", "clear", "(", ")", ";", "PushPopMIs", ".", "clear", "(", ")", ";", "T2JumpTables", ".", "clear", "(", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "2", "2", "0", "0", "0", "30", "\"Constant Island pass failed to converge!\"", "0", "30", "\"Branch Fix Up pass failed to converge!\"" ]

[]

[ "<s>", "bool", "R600TargetLowering", "::", "isZero", "(", "SDValue", "Op", ")", "const", "{", "if", "(", "ConstantSDNode", "*", "Cst", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "return", "Cst", "->", "isNullValue", "(", ")", ";", "}", "else", "if", "(", "ConstantFPSDNode", "*", "CstFP", "=", "dyn_cast", "<", "ConstantFPSDNode", ">", "(", "Op", ")", ")", "{", "return", "CstFP", "->", "isZero", "(", ")", ";", "}", "else", "{", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "the", "expression", "is", "a", "constant", "zero", "." ]

[ "R600" ]

[]

[ "<s>", "void", "X86TargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "KnownBits", "&", "Known", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "BitWidth", "=", "Known", ".", "getBitWidth", "(", ")", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "assert", "(", "(", "Opc", ">=", "ISD", "::", "BUILTIN_OP_END", "||", "Opc", "==", "ISD", "::", "INTRINSIC_WO_CHAIN", "||", "Opc", "==", "ISD", "::", "INTRINSIC_W_CHAIN", "||", "Opc", "==", "ISD", "::", "INTRINSIC_VOID", ")", "&&", "\"Should use MaskedValueIsZero if you don't know whether Op\"", "\" is a target node!\"", ")", ";", "Known", ".", "resetAll", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "X86ISD", "::", "SETCC", ":", "Known", ".", "Zero", ".", "setBitsFrom", "(", "1", ")", ";", "break", ";", "case", "X86ISD", "::", "MOVMSK", ":", "{", "unsigned", "NumLoBits", "=", "Op", ".", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", ".", "getVectorNumElements", "(", ")", ";", "Known", ".", "Zero", ".", "setBitsFrom", "(", "NumLoBits", ")", ";", "break", ";", "}", "case", "X86ISD", "::", "VSHLI", ":", "case", "X86ISD", "::", "VSRLI", ":", "{", "if", "(", "auto", "*", "ShiftImm", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "1", ")", ")", ")", "{", "if", "(", "ShiftImm", "->", "getAPIntValue", "(", ")", ".", "uge", "(", "VT", ".", "getScalarSizeInBits", "(", ")", ")", ")", "{", "Known", ".", "setAllZero", "(", ")", ";", "break", ";", "}", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "Known", ",", "Depth", "+", "1", ")", ";", "unsigned", "ShAmt", "=", "ShiftImm", "->", "getZExtValue", "(", ")", ";", "if", "(", "Opc", "==", "X86ISD", "::", "VSHLI", ")", "{", "Known", ".", "Zero", "<<=", "ShAmt", ";", "Known", ".", "One", "<<=", "ShAmt", ";", "Known", ".", "Zero", ".", "setLowBits", "(", "ShAmt", ")", ";", "}", "else", "{", "Known", ".", "Zero", ".", "lshrInPlace", "(", "ShAmt", ")", ";", "Known", ".", "One", ".", "lshrInPlace", "(", "ShAmt", ")", ";", "Known", ".", "Zero", ".", "setHighBits", "(", "ShAmt", ")", ";", "}", "}", "break", ";", "}", "case", "X86ISD", "::", "VZEXT", ":", "{", "SDValue", "N0", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "EVT", "SrcVT", "=", "N0", ".", "getValueType", "(", ")", ";", "unsigned", "InNumElts", "=", "SrcVT", ".", "getVectorNumElements", "(", ")", ";", "unsigned", "InBitWidth", "=", "SrcVT", ".", "getScalarSizeInBits", "(", ")", ";", "assert", "(", "InNumElts", ">=", "NumElts", "&&", "\"Illegal VZEXT input\"", ")", ";", "Known", "=", "KnownBits", "(", "InBitWidth", ")", ";", "APInt", "DemandedSrcElts", "=", "APInt", "::", "getLowBitsSet", "(", "InNumElts", ",", "NumElts", ")", ";", "DAG", ".", "computeKnownBits", "(", "N0", ",", "Known", ",", "DemandedSrcElts", ",", "Depth", "+", "1", ")", ";", "Known", "=", "Known", ".", "zext", "(", "BitWidth", ")", ";", "Known", ".", "Zero", ".", "setBitsFrom", "(", "InBitWidth", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "X86", "X86", "ISD::BUILTIN_OP_END", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_W_CHAIN", "ISD::INTRINSIC_VOID", "\"Should use MaskedValueIsZero if you don't know whether Op\"", "\" is a target node!\"", "X86ISD::SETCC", "1", "X86ISD::MOVMSK", "0", "X86ISD::VSHLI", "X86ISD::VSRLI", "1", "0", "1", "X86ISD::VSHLI", "X86ISD::VZEXT", "0", "\"Illegal VZEXT input\"", "1" ]

[]

[ "<s>", "rtx", "mmix_get_hard_reg_initial_val", "(", "machine_mode", "mode", ",", "int", "regno", ")", "{", "return", "get_hard_reg_initial_val", "(", "mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Wrapper", "for", "get_hard_reg_initial_val", "since", "integrate.h", "is", "n't", "included", "from", "insn-emit.cc", "." ]

[ "mmix" ]

[]

[ "<s>", "rtx", "ix86_memtag_extract_tag", "(", "rtx", "tagged_pointer", ",", "rtx", "target", ")", "{", "rtx", "tag", "=", "expand_simple_binop", "(", "Pmode", ",", "LSHIFTRT", ",", "tagged_pointer", ",", "GEN_INT", "(", "IX86_HWASAN_SHIFT", ")", ",", "target", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "rtx", "ret", "=", "gen_reg_rtx", "(", "QImode", ")", ";", "if", "(", "ix86_lam_type", "==", "lam_u57", ")", "{", "unsigned", "HOST_WIDE_INT", "and_imm", "=", "(", "HOST_WIDE_INT_1U", "<<", "IX86_HWASAN_TAG_SIZE", ")", "-", "1", ";", "emit_insn", "(", "gen_andqi3", "(", "ret", ",", "gen_lowpart", "(", "QImode", ",", "tag", ")", ",", "gen_int_mode", "(", "and_imm", ",", "QImode", ")", ")", ")", ";", "}", "else", "emit_move_insn", "(", "ret", ",", "gen_lowpart", "(", "QImode", ",", "tag", ")", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Implement", "TARGET_MEMTAG_EXTRACT_TAG", "." ]

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

[]

[ "<s>", "void", "HSAILModuleInfo", "::", "processModule", "(", "const", "Module", "*", "M", ",", "const", "HSAILTargetMachine", "*", "mTM", ")", "{", "mSTM", "=", "mTM", "->", "getSubtargetImpl", "(", ")", ";", "if", "(", "mProcessed", ")", "{", "return", ";", "}", "mProcessed", "=", "true", ";", "}", "</s>" ]

[ "Process", "entire", "module", "and", "collect", "debug", "info", "anchors", "." ]

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

[]

[ "<s>", "static", "int", "no_previous_def", "(", "tree", "function_name", ")", "{", "tree", "branch_island", ";", "for", "(", "branch_island", "=", "branch_island_list", ";", "branch_island", ";", "branch_island", "=", "TREE_CHAIN", "(", "branch_island", ")", ")", "if", "(", "function_name", "==", "BRANCH_ISLAND_FUNCTION_NAME", "(", "branch_island", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "NO_PREVIOUS_DEF", "checks", "in", "the", "link", "list", "whether", "the", "function", "name", "is", "already", "there", "or", "not", "." ]

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

[]

[ "<s>", "bool", "SPIRVAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

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

[]

[ "<s>", "static", "int", "compute_total_frame_size", "(", "void", ")", "{", "int", "total_size", "=", "(", "get_frame_size", "(", ")", "+", "tilepro_saved_regs_size", "(", ")", "+", "crtl", "->", "outgoing_args_size", "+", "crtl", "->", "args", ".", "pretend_args_size", ")", ";", "if", "(", "!", "tilepro_current_function_is_leaf", "(", ")", "||", "cfun", "->", "calls_alloca", ")", "{", "total_size", "+=", "STACK_POINTER_OFFSET", ";", "}", "return", "round_frame_size", "(", "total_size", ")", ";", "}", "</s>" ]

[ "Return", "the", "frame", "size", "." ]

[ "tilepro" ]

[]

[ "<s>", "bool", "Thumb1FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "bool", "isVarArg", "=", "AFI", "->", "getArgRegsSaveSize", "(", ")", ">", "0", ";", "DebugLoc", "DL", "=", "MI", "!=", "MBB", ".", "end", "(", ")", "?", "MI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tPOP", ")", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "bool", "NeedsPop", "=", "false", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "ARM", "::", "LR", ")", "{", "if", "(", "MBB", ".", "succ_empty", "(", ")", ")", "{", "if", "(", "isVarArg", ")", "continue", ";", "if", "(", "!", "STI", ".", "hasV5TOps", "(", ")", ")", "continue", ";", "Reg", "=", "ARM", "::", "PC", ";", "(", "*", "MIB", ")", ".", "setDesc", "(", "TII", ".", "get", "(", "ARM", "::", "tPOP_RET", ")", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "MIB", ".", "copyImplicitOps", "(", "&", "*", "MI", ")", ";", "MI", "=", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "else", "continue", ";", "}", "MIB", ".", "addReg", "(", "Reg", ",", "getDefRegState", "(", "true", ")", ")", ";", "NeedsPop", "=", "true", ";", "}", "if", "(", "NeedsPop", ")", "MBB", ".", "insert", "(", "MI", ",", "&", "*", "MIB", ")", ";", "else", "MF", ".", "DeleteMachineInstr", "(", "MIB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "0", "ARM::tPOP", "0", "1", "ARM::LR", "ARM::PC", "ARM::tPOP_RET" ]

[]

[ "<s>", "const", "uint16_t", "*", "DLXRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", ")", "const", "{", "const", "uint16_t", "t", "=", "5", ";", "return", "&", "t", ";", "}", "</s>" ]

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

[ "DLX", "DLX", "5" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "unsigned", "Opc", "=", "N", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SDIVREM", ":", "case", "ISD", "::", "UDIVREM", ":", "return", "performDivRemCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "performSELECTCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "MipsISD", "::", "CMovFP_F", ":", "case", "MipsISD", "::", "CMovFP_T", ":", "return", "performCMovFPCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "performANDCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "performORCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "performADDCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AssertZext", ":", "return", "performAssertZextCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::SDIVREM", "ISD::UDIVREM", "ISD::SELECT", "MipsISD::CMovFP_F", "MipsISD::CMovFP_T", "ISD::AND", "ISD::OR", "ISD::ADD", "ISD::AssertZext" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "void", "btf_ext_output", "(", "void", ")", "{", "output_btfext_header", "(", ")", ";", "output_btfext_core_sections", "(", ")", ";", "bpf_core_sections", "=", "NULL", ";", "}", "</s>" ]

[ "Output", "the", "entire", ".BTF.ext", "section", "." ]

[ "bpf" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "ARMBaseInstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "const", "InstrItineraryData", "*", "II", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "if", "(", "Subtarget", ".", "isThumb2", "(", ")", "||", "Subtarget", ".", "hasVFP2", "(", ")", ")", "return", "(", "ScheduleHazardRecognizer", "*", ")", "new", "ARMHazardRecognizer", "(", "II", ",", "*", "this", ",", "getRegisterInfo", "(", ")", ",", "Subtarget", ",", "DAG", ")", ";", "return", "TargetInstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "by", "non-scheduling", "passes", "." ]

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

[]

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

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

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

[]

[ "<s>", "static", "bool", "bfin_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "if", "(", "bfin_valid_reg_p", "(", "REGNO", "(", "x", ")", ",", "strict", ",", "mode", ",", "MEM", ")", ")", "return", "true", ";", "break", ";", "case", "PLUS", ":", "if", "(", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "bfin_valid_reg_p", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ",", "strict", ",", "mode", ",", "PLUS", ")", "&&", "(", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "UNSPEC", "&&", "mode", "==", "SImode", ")", "||", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "bfin_valid_add", "(", "mode", ",", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ")", ")", ")", "return", "true", ";", "break", ";", "case", "POST_INC", ":", "case", "POST_DEC", ":", "if", "(", "LEGITIMATE_MODE_FOR_AUTOINC_P", "(", "mode", ")", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "bfin_valid_reg_p", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ",", "strict", ",", "mode", ",", "POST_INC", ")", ")", "return", "true", ";", "break", ";", "case", "PRE_DEC", ":", "if", "(", "LEGITIMATE_MODE_FOR_AUTOINC_P", "(", "mode", ")", "&&", "XEXP", "(", "x", ",", "0", ")", "==", "stack_pointer_rtx", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "bfin_valid_reg_p", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ",", "strict", ",", "mode", ",", "PRE_DEC", ")", ")", "return", "true", ";", "break", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Recognize", "an", "RTL", "expression", "that", "is", "a", "valid", "memory", "address", "for", "an", "instruction", ".", "The", "MODE", "argument", "is", "the", "machine", "mode", "for", "the", "MEM", "expression", "that", "wants", "to", "use", "this", "address", ".", "Blackfin", "addressing", "modes", "are", "as", "follows", ":", "[", "preg", "]", "[", "preg", "+", "imm16", "]", "B", "[", "Preg", "+", "uimm15", "]", "W", "[", "Preg", "+", "uimm16m2", "]", "[", "Preg", "+", "uimm17m4", "]", "[", "preg++", "]", "[", "preg", "--", "]", "[", "--", "sp", "]" ]

[ "bfin", "0", "0", "1", "1", "1", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "unsigned", "Z80InstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "auto", "TSFlags", "=", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", ";", "unsigned", "Size", "=", "1", ";", "switch", "(", "TSFlags", ">>", "Z80II", "::", "ImmSizeShift", "&", "Z80II", "::", "ImmSizeMask", ")", "{", "case", "2", ":", "Size", "+=", "Subtarget", ".", "is24Bit", "(", ")", ";", "break", ";", "case", "3", ":", "Size", "+=", "Subtarget", ".", "is16Bit", "(", ")", ";", "break", ";", "}", "unsigned", "Prefix", "=", "TSFlags", ">>", "Z80II", "::", "PrefixShift", "&", "Z80II", "::", "PrefixMask", ";", "bool", "HasPrefix", ";", "if", "(", "TSFlags", "&", "Z80II", "::", "IndexedIndexPrefix", ")", "Size", "+=", "HasPrefix", "=", "isIndex", "(", "MI", ".", "getOperand", "(", "Prefix", ")", ",", "getRegisterInfo", "(", ")", ")", ";", "else", "switch", "(", "Prefix", ")", "{", "case", "Z80II", "::", "NoPrefix", ":", "HasPrefix", "=", "false", ";", "break", ";", "case", "Z80II", "::", "CBPrefix", ":", "case", "Z80II", "::", "DDPrefix", ":", "case", "Z80II", "::", "EDPrefix", ":", "case", "Z80II", "::", "FDPrefix", ":", "Size", "+=", "1", ";", "HasPrefix", "=", "true", ";", "break", ";", "case", "Z80II", "::", "DDCBPrefix", ":", "case", "Z80II", "::", "FDCBPrefix", ":", "Size", "+=", "2", ";", "HasPrefix", "=", "true", ";", "break", ";", "case", "Z80II", "::", "AnyIndexPrefix", ":", "Size", "+=", "HasPrefix", "=", "hasIndex", "(", "MI", ",", "getRegisterInfo", "(", ")", ")", ";", "break", ";", "}", "if", "(", "TSFlags", "&", "Z80II", "::", "HasImm", ")", "{", "unsigned", "ImmSize", "=", "TSFlags", ">>", "Z80II", "::", "ImmSizeShift", "&", "Z80II", "::", "ImmSizeMask", ";", "if", "(", "!", "ImmSize", ")", "ImmSize", "=", "Subtarget", ".", "is24Bit", "(", ")", "?", "3", ":", "2", ";", "Size", "+=", "ImmSize", ";", "}", "if", "(", "TSFlags", "&", "Z80II", "::", "HasOff", ")", "Size", "+=", "HasPrefix", ";", "return", "Size", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "1", "Z80II::ImmSizeShift", "Z80II::ImmSizeMask", "2", "3", "Z80II::PrefixShift", "Z80II::PrefixMask", "Z80II::IndexedIndexPrefix", "Z80II::NoPrefix", "Z80II::CBPrefix", "Z80II::DDPrefix", "Z80II::EDPrefix", "Z80II::FDPrefix", "1", "Z80II::DDCBPrefix", "Z80II::FDCBPrefix", "2", "Z80II::AnyIndexPrefix", "Z80II::HasImm", "Z80II::ImmSizeShift", "Z80II::ImmSizeMask", "3", "2", "Z80II::HasOff" ]

[]

[ "<s>", "static", "void", "s390_update_frame_layout", "(", "void", ")", "{", "int", "clobbered_regs", "[", "16", "]", ";", "s390_register_info", "(", "clobbered_regs", ")", ";", "regs_ever_live", "[", "BASE_REGNUM", "]", "=", "clobbered_regs", "[", "BASE_REGNUM", "]", ";", "regs_ever_live", "[", "RETURN_REGNUM", "]", "=", "clobbered_regs", "[", "RETURN_REGNUM", "]", ";", "regs_ever_live", "[", "STACK_POINTER_REGNUM", "]", "=", "clobbered_regs", "[", "STACK_POINTER_REGNUM", "]", ";", "if", "(", "cfun", "->", "machine", "->", "base_reg", ")", "regs_ever_live", "[", "REGNO", "(", "cfun", "->", "machine", "->", "base_reg", ")", "]", "=", "1", ";", "}", "</s>" ]

[ "Update", "frame", "layout", ".", "Recompute", "actual", "register", "save", "data", "based", "on", "current", "info", "and", "update", "regs_ever_live", "for", "the", "special", "registers", ".", "May", "be", "called", "multiple", "times", ",", "but", "may", "never", "cause", "*", "more", "*", "registers", "to", "be", "saved", "than", "s390_init_frame_layout", "allocated", "room", "for", "." ]

[ "s390", "16", "1" ]

[]

[ "<s>", "static", "tree", "rs6000_handle_altivec_attribute", "(", "tree", "*", "node", ",", "tree", "name", "ATTRIBUTE_UNUSED", ",", "tree", "args", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "tree", "type", "=", "*", "node", ",", "result", "=", "NULL_TREE", ";", "enum", "machine_mode", "mode", ";", "int", "unsigned_p", ";", "char", "altivec_type", "=", "(", "(", "args", "&&", "TREE_CODE", "(", "args", ")", "==", "TREE_LIST", "&&", "TREE_VALUE", "(", "args", ")", "&&", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "==", "IDENTIFIER_NODE", ")", "?", "*", "IDENTIFIER_POINTER", "(", "TREE_VALUE", "(", "args", ")", ")", ":", "'?'", ")", ";", "while", "(", "POINTER_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "type", ")", "==", "FUNCTION_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "METHOD_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "if", "(", "type", "==", "long_unsigned_type_node", "||", "type", "==", "long_integer_type_node", ")", "{", "if", "(", "TARGET_64BIT", ")", "error", "(", "\"use of %<long%> in AltiVec types is invalid for 64-bit code\"", ")", ";", "else", "if", "(", "rs6000_warn_altivec_long", ")", "warning", "(", "0", ",", "\"use of %<long%> in AltiVec types is deprecated; use %<int%>\"", ")", ";", "}", "else", "if", "(", "type", "==", "long_long_unsigned_type_node", "||", "type", "==", "long_long_integer_type_node", ")", "error", "(", "\"use of %<long long%> in AltiVec types is invalid\"", ")", ";", "else", "if", "(", "type", "==", "double_type_node", ")", "error", "(", "\"use of %<double%> in AltiVec types is invalid\"", ")", ";", "else", "if", "(", "type", "==", "long_double_type_node", ")", "error", "(", "\"use of %<long double%> in AltiVec types is invalid\"", ")", ";", "else", "if", "(", "type", "==", "boolean_type_node", ")", "error", "(", "\"use of boolean types in AltiVec types is invalid\"", ")", ";", "else", "if", "(", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", ")", "error", "(", "\"use of %<complex%> in AltiVec types is invalid\"", ")", ";", "switch", "(", "altivec_type", ")", "{", "case", "'v'", ":", "unsigned_p", "=", "TYPE_UNSIGNED", "(", "type", ")", ";", "switch", "(", "mode", ")", "{", "case", "SImode", ":", "result", "=", "(", "unsigned_p", "?", "unsigned_V4SI_type_node", ":", "V4SI_type_node", ")", ";", "break", ";", "case", "HImode", ":", "result", "=", "(", "unsigned_p", "?", "unsigned_V8HI_type_node", ":", "V8HI_type_node", ")", ";", "break", ";", "case", "QImode", ":", "result", "=", "(", "unsigned_p", "?", "unsigned_V16QI_type_node", ":", "V16QI_type_node", ")", ";", "break", ";", "case", "SFmode", ":", "result", "=", "V4SF_type_node", ";", "break", ";", "case", "V4SImode", ":", "case", "V8HImode", ":", "case", "V16QImode", ":", "case", "V4SFmode", ":", "result", "=", "type", ";", "default", ":", "break", ";", "}", "break", ";", "case", "'b'", ":", "switch", "(", "mode", ")", "{", "case", "SImode", ":", "case", "V4SImode", ":", "result", "=", "bool_V4SI_type_node", ";", "break", ";", "case", "HImode", ":", "case", "V8HImode", ":", "result", "=", "bool_V8HI_type_node", ";", "break", ";", "case", "QImode", ":", "case", "V16QImode", ":", "result", "=", "bool_V16QI_type_node", ";", "default", ":", "break", ";", "}", "break", ";", "case", "'p'", ":", "switch", "(", "mode", ")", "{", "case", "V8HImode", ":", "result", "=", "pixel_V8HI_type_node", ";", "default", ":", "break", ";", "}", "default", ":", "break", ";", "}", "if", "(", "result", "&&", "result", "!=", "type", "&&", "TYPE_READONLY", "(", "type", ")", ")", "result", "=", "build_qualified_type", "(", "result", ",", "TYPE_QUAL_CONST", ")", ";", "*", "no_add_attrs", "=", "true", ";", "if", "(", "result", ")", "*", "node", "=", "reconstruct_complex_type", "(", "*", "node", ",", "result", ")", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "the", "``", "altivec", "''", "attribute", ".", "The", "attribute", "may", "have", "arguments", "as", "follows", ":", "__attribute__", "(", "(", "altivec", "(", "vector__", ")", ")", ")", "__attribute__", "(", "(", "altivec", "(", "pixel__", ")", ")", ")", "(", "always", "followed", "by", "'unsigned", "short", "'", ")", "__attribute__", "(", "(", "altivec", "(", "bool__", ")", ")", ")", "(", "always", "followed", "by", "'unsigned", "'", ")", "and", "may", "appear", "more", "than", "once", "(", "e.g.", ",", "'vector", "bool", "char", "'", ")", "in", "a", "given", "declaration", "." ]

[ "rs6000", "\"use of %<long%> in AltiVec types is invalid for 64-bit code\"", "0", "\"use of %<long%> in AltiVec types is deprecated; use %<int%>\"", "\"use of %<long long%> in AltiVec types is invalid\"", "\"use of %<double%> in AltiVec types is invalid\"", "\"use of %<long double%> in AltiVec types is invalid\"", "\"use of boolean types in AltiVec types is invalid\"", "\"use of %<complex%> in AltiVec types is invalid\"" ]

[]

[ "<s>", "static", "bool", "aarch64_evpc_rev_local", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "HOST_WIDE_INT", "diff", ";", "unsigned", "int", "i", ",", "size", ",", "unspec", ";", "machine_mode", "pred_mode", ";", "if", "(", "d", "->", "vec_flags", "==", "VEC_SVE_PRED", "||", "!", "d", "->", "one_vector_p", "||", "!", "d", "->", "perm", "[", "0", "]", ".", "is_constant", "(", "&", "diff", ")", "||", "!", "diff", ")", "return", "false", ";", "if", "(", "d", "->", "vec_flags", "&", "VEC_SVE_DATA", ")", "size", "=", "(", "diff", "+", "1", ")", "*", "aarch64_sve_container_bits", "(", "d", "->", "vmode", ")", ";", "else", "size", "=", "(", "diff", "+", "1", ")", "*", "GET_MODE_UNIT_BITSIZE", "(", "d", "->", "vmode", ")", ";", "if", "(", "size", "==", "64", ")", "{", "unspec", "=", "UNSPEC_REV64", ";", "pred_mode", "=", "VNx2BImode", ";", "}", "else", "if", "(", "size", "==", "32", ")", "{", "unspec", "=", "UNSPEC_REV32", ";", "pred_mode", "=", "VNx4BImode", ";", "}", "else", "if", "(", "size", "==", "16", ")", "{", "unspec", "=", "UNSPEC_REV16", ";", "pred_mode", "=", "VNx8BImode", ";", "}", "else", "return", "false", ";", "unsigned", "int", "step", "=", "diff", "+", "1", ";", "for", "(", "i", "=", "0", ";", "i", "<", "step", ";", "++", "i", ")", "if", "(", "!", "d", "->", "perm", ".", "series_p", "(", "i", ",", "step", ",", "diff", "-", "i", ",", "step", ")", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "if", "(", "d", "->", "vec_flags", "&", "VEC_SVE_DATA", ")", "{", "rtx", "pred", "=", "aarch64_ptrue_reg", "(", "pred_mode", ")", ";", "emit_insn", "(", "gen_aarch64_sve_revbhw", "(", "d", "->", "vmode", ",", "pred_mode", ",", "d", "->", "target", ",", "pred", ",", "d", "->", "op0", ")", ")", ";", "return", "true", ";", "}", "rtx", "src", "=", "gen_rtx_UNSPEC", "(", "d", "->", "vmode", ",", "gen_rtvec", "(", "1", ",", "d", "->", "op0", ")", ",", "unspec", ")", ";", "emit_set_insn", "(", "d", "->", "target", ",", "src", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "the", "REV", "{", "64,32,16", "}", "insns", ",", "which", "reverse", "elements", "within", "each", "64-bit", ",", "32-bit", "or", "16-bit", "granule", "." ]

[ "aarch64", "0", "1", "1", "64", "32", "16", "1", "0", "1" ]

[]

[ "<s>", "static", "bool", "loongarch_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "mode1", "==", "mode2", "||", "(", "!", "loongarch_mode_ok_for_mov_fmt_p", "(", "mode1", ")", "&&", "!", "loongarch_mode_ok_for_mov_fmt_p", "(", "mode2", ")", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MODES_TIEABLE_P", "." ]

[ "loongarch" ]

[]

[ "<s>", "unsigned", "BPFMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "MRI", ".", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "assert", "(", "Expr", "->", "getKind", "(", ")", "==", "MCExpr", "::", "SymbolRef", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "BPF", "::", "JAL", ")", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "FK_SecRel_4", ")", ")", ";", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "BPF", "::", "LD_imm64", ")", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "FK_SecRel_8", ")", ")", ";", "else", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "FK_PCRel_2", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "BPF::JAL", "0", "BPF::LD_imm64", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "mips_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "struct", "mips_arg_info", "info", ";", "mips_get_arg_info", "(", "&", "info", ",", "cum", ",", "mode", ",", "type", ",", "named", ")", ";", "if", "(", "!", "info", ".", "fpr_p", ")", "cum", "->", "gp_reg_found", "=", "true", ";", "if", "(", "cum", "->", "arg_number", "<", "2", "&&", "info", ".", "fpr_p", ")", "cum", "->", "fp_code", "+=", "(", "mode", "==", "SFmode", "?", "1", ":", "2", ")", "<<", "(", "cum", "->", "arg_number", "*", "2", ")", ";", "if", "(", "mips_abi", "!=", "ABI_EABI", "||", "!", "info", ".", "fpr_p", ")", "cum", "->", "num_gprs", "=", "info", ".", "reg_offset", "+", "info", ".", "reg_words", ";", "else", "if", "(", "info", ".", "reg_words", ">", "0", ")", "cum", "->", "num_fprs", "+=", "MAX_FPRS_PER_FMT", ";", "if", "(", "info", ".", "stack_words", ">", "0", ")", "cum", "->", "stack_words", "=", "info", ".", "stack_offset", "+", "info", ".", "stack_words", ";", "cum", "->", "arg_number", "++", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG_ADVANCE", "." ]

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

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isMulAddWithConstProfitable", "(", "SDValue", "AddNode", ",", "SDValue", "ConstNode", ")", "const", "{", "EVT", "VT", "=", "AddNode", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "true", ";", "if", "(", "VT", ".", "getScalarSizeInBits", "(", ")", ">", "Subtarget", ".", "getXLen", "(", ")", ")", "return", "true", ";", "ConstantSDNode", "*", "C1Node", "=", "cast", "<", "ConstantSDNode", ">", "(", "AddNode", ".", "getOperand", "(", "1", ")", ")", ";", "ConstantSDNode", "*", "C2Node", "=", "cast", "<", "ConstantSDNode", ">", "(", "ConstNode", ")", ";", "const", "APInt", "&", "C1", "=", "C1Node", "->", "getAPIntValue", "(", ")", ";", "const", "APInt", "&", "C2", "=", "C2Node", "->", "getAPIntValue", "(", ")", ";", "if", "(", "C1", ".", "isSignedIntN", "(", "12", ")", "&&", "!", "(", "C1", "*", "C2", ")", ".", "isSignedIntN", "(", "12", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "may", "be", "profitable", "to", "transform", "(", "mul", "(", "add", "x", ",", "c1", ")", ",", "c2", ")", "-", ">", "(", "add", "(", "mul", "x", ",", "c2", ")", ",", "c1", "*", "c2", ")", "." ]

[ "RISCV", "RISCV", "1", "12", "12" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "optimizeCompareInstr", "(", "MachineInstr", "&", "Compare", ",", "unsigned", "SrcReg", ",", "unsigned", "SrcReg2", ",", "int", "Mask", ",", "int", "Value", ",", "const", "MachineRegisterInfo", "*", "MRI", ")", "const", "{", "assert", "(", "!", "SrcReg2", "&&", "\"Only optimizing constant comparisons so far\"", ")", ";", "bool", "IsLogical", "=", "(", "Compare", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "SystemZII", "::", "IsLogical", ")", "!=", "0", ";", "return", "Value", "==", "0", "&&", "!", "IsLogical", "&&", "removeIPMBasedCompare", "(", "Compare", ",", "SrcReg", ",", "MRI", ",", "&", "RI", ")", ";", "}", "</s>" ]

[ "optimizeCompareInstr", "-", "Check", "if", "there", "exists", "an", "earlier", "instruction", "that", "operates", "on", "the", "same", "source", "operands", "and", "sets", "flags", "in", "the", "same", "way", "as", "Compare", ";", "remove", "Compare", "if", "possible", "." ]

[ "SystemZ", "SystemZ", "\"Only optimizing constant comparisons so far\"", "SystemZII::IsLogical", "0", "0" ]

[]

[ "<s>", "static", "void", "rs6000_secondary_reload_trace", "(", "int", "line", ",", "rtx", "reg", ",", "rtx", "mem", ",", "rtx", "scratch", ",", "bool", "store_p", ")", "{", "rtx", "set", ",", "clobber", ";", "gcc_assert", "(", "reg", "!=", "NULL_RTX", "&&", "mem", "!=", "NULL_RTX", "&&", "scratch", "!=", "NULL_RTX", ")", ";", "fprintf", "(", "stderr", ",", "\"rs6000_secondary_reload_inner:%d, type = %s\\n\"", ",", "line", ",", "store_p", "?", "\"store\"", ":", "\"load\"", ")", ";", "if", "(", "store_p", ")", "set", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "else", "set", "=", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ";", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "scratch", ")", ";", "debug_rtx", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "clobber", ")", ")", ")", ";", "}", "</s>" ]

[ "Better", "tracing", "for", "rs6000_secondary_reload_inner", "." ]

[ "rs6000", "\"rs6000_secondary_reload_inner:%d, type = %s\\n\"", "\"store\"", "\"load\"", "2" ]

[]

[ "<s>", "bool", "X86CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "unsigned", "Idx", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "getArgumentList", "(", ")", ")", "{", "ArgInfo", "OrigArg", "(", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "OrigArg", ",", "Idx", "+", "1", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "ArrayRef", "<", "unsigned", ">", "Regs", ",", "ArrayRef", "<", "uint64_t", ">", "Offsets", ")", "{", "MIRBuilder", ".", "buildSequence", "(", "VRegs", "[", "Idx", "]", ",", "Regs", ",", "Offsets", ")", ";", "}", ")", ";", "Idx", "++", ";", "}", "MachineBasicBlock", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "FormalArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "CC_X86", ",", "DL", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "loongarch_move_integer", "(", "rtx", "temp", ",", "rtx", "dest", ",", "unsigned", "HOST_WIDE_INT", "value", ")", "{", "struct", "loongarch_integer_op", "codes", "[", "LARCH_MAX_INTEGER_OPS", "]", ";", "machine_mode", "mode", ";", "unsigned", "int", "i", ",", "num_ops", ";", "rtx", "x", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "num_ops", "=", "loongarch_build_integer", "(", "codes", ",", "value", ")", ";", "x", "=", "GEN_INT", "(", "codes", "[", "0", "]", ".", "value", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<", "num_ops", ";", "i", "++", ")", "{", "if", "(", "!", "can_create_pseudo_p", "(", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "temp", ",", "x", ")", ")", ";", "x", "=", "temp", ";", "}", "else", "x", "=", "force_reg", "(", "mode", ",", "x", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "GEN_INT", "(", "codes", "[", "i", "-", "1", "]", ".", "curr_value", ")", ")", ";", "switch", "(", "codes", "[", "i", "]", ".", "method", ")", "{", "case", "METHOD_NORMAL", ":", "x", "=", "gen_rtx_fmt_ee", "(", "codes", "[", "i", "]", ".", "code", ",", "mode", ",", "x", ",", "GEN_INT", "(", "codes", "[", "i", "]", ".", "value", ")", ")", ";", "break", ";", "case", "METHOD_LU32I", ":", "gcc_assert", "(", "mode", "==", "DImode", ")", ";", "x", "=", "gen_rtx_IOR", "(", "DImode", ",", "gen_rtx_ZERO_EXTEND", "(", "DImode", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "x", ",", "0", ")", ")", ",", "GEN_INT", "(", "codes", "[", "i", "]", ".", "value", ")", ")", ";", "break", ";", "case", "METHOD_LU52I", ":", "gcc_assert", "(", "mode", "==", "DImode", ")", ";", "x", "=", "gen_rtx_IOR", "(", "DImode", ",", "gen_rtx_AND", "(", "DImode", ",", "x", ",", "GEN_INT", "(", "0xfffffffffffff", ")", ")", ",", "GEN_INT", "(", "codes", "[", "i", "]", ".", "value", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "x", ")", ")", ";", "}", "</s>" ]

[ "Load", "VALUE", "into", "DEST", ".", "TEMP", "is", "as", "for", "loongarch_force_temporary", "." ]

[ "loongarch", "0", "1", "1", "0", "0xfffffffffffff" ]

[]

[ "<s>", "rtx", "m68k_function_value", "(", "const_tree", "valtype", ",", "const_tree", "func", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "mode", ";", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "case", "E_XFmode", ":", "if", "(", "TARGET_68881", ")", "return", "gen_rtx_REG", "(", "mode", ",", "FP0_REG", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "func", "&&", "POINTER_TYPE_P", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "func", ")", ")", ")", ")", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "A0_REG", ")", ",", "const0_rtx", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "D0_REG", ")", ",", "const0_rtx", ")", ")", ")", ";", "else", "if", "(", "POINTER_TYPE_P", "(", "valtype", ")", ")", "return", "gen_rtx_REG", "(", "mode", ",", "A0_REG", ")", ";", "else", "return", "gen_rtx_REG", "(", "mode", ",", "D0_REG", ")", ";", "}", "</s>" ]

[ "Location", "in", "which", "function", "value", "is", "returned", ".", "NOTE", ":", "Due", "to", "differences", "in", "ABIs", ",", "do", "n't", "call", "this", "function", "directly", ",", "use", "FUNCTION_VALUE", "instead", "." ]

[ "m68k", "2" ]

[]

[ "<s>", "static", "inline", "tree", "def_builtin2", "(", "HOST_WIDE_INT", "mask", ",", "const", "char", "*", "name", ",", "enum", "ix86_builtin_func_type", "tcode", ",", "enum", "ix86_builtins", "code", ")", "{", "tree", "decl", "=", "NULL_TREE", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "isa2", "=", "mask", ";", "if", "(", "mask", "==", "0", "||", "(", "mask", "&", "ix86_isa_flags2", ")", "!=", "0", "||", "(", "lang_hooks", ".", "builtin_function", "==", "lang_hooks", ".", "builtin_function_ext_scope", ")", ")", "{", "tree", "type", "=", "ix86_get_builtin_func_type", "(", "tcode", ")", ";", "decl", "=", "add_builtin_function", "(", "name", ",", "type", ",", "code", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "ix86_builtins", "[", "(", "int", ")", "code", "]", "=", "decl", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "set_and_not_built_p", "=", "false", ";", "}", "else", "{", "deferred_isa_values2", "|=", "mask", ";", "ix86_builtins", "[", "(", "int", ")", "code", "]", "=", "NULL_TREE", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "tcode", "=", "tcode", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "name", "=", "name", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "leaf_p", "=", "false", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "nothrow_p", "=", "false", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "const_p", "=", "false", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "pure_p", "=", "false", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "set_and_not_built_p", "=", "true", ";", "}", "return", "decl", ";", "}", "</s>" ]

[ "Like", "def_builtin", ",", "but", "for", "additional", "isa2", "flags", "." ]

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

[]

[ "<s>", "rtx", "rs6000_libcall_value", "(", "enum", "machine_mode", "mode", ")", "{", "unsigned", "int", "regno", ";", "if", "(", "TARGET_32BIT", "&&", "TARGET_POWERPC64", "&&", "mode", "==", "DImode", ")", "{", "return", "gen_rtx_PARALLEL", "(", "DImode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "SImode", ",", "GP_ARG_RETURN", ")", ",", "const0_rtx", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "SImode", ",", "GP_ARG_RETURN", "+", "1", ")", ",", "GEN_INT", "(", "4", ")", ")", ")", ")", ";", "}", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "&&", "TARGET_HARD_FLOAT", "&&", "TARGET_FPRS", ")", "regno", "=", "FP_ARG_RETURN", ";", "else", "if", "(", "ALTIVEC_VECTOR_MODE", "(", "mode", ")", "&&", "TARGET_ALTIVEC", "&&", "TARGET_ALTIVEC_ABI", ")", "regno", "=", "ALTIVEC_ARG_RETURN", ";", "else", "if", "(", "COMPLEX_MODE_P", "(", "mode", ")", "&&", "targetm", ".", "calls", ".", "split_complex_arg", ")", "return", "rs6000_complex_function_value", "(", "mode", ")", ";", "else", "if", "(", "TARGET_E500_DOUBLE", "&&", "TARGET_HARD_FLOAT", "&&", "(", "mode", "==", "DFmode", "||", "mode", "==", "DCmode", ")", ")", "return", "spe_build_register_parallel", "(", "mode", ",", "GP_ARG_RETURN", ")", ";", "else", "regno", "=", "GP_ARG_RETURN", ";", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "arm_coproc_mem_operand", "(", "rtx", "op", ",", "bool", "wb", ")", "{", "rtx", "ind", ";", "if", "(", "!", "(", "reload_in_progress", "||", "reload_completed", ")", "&&", "(", "reg_mentioned_p", "(", "frame_pointer_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "arg_pointer_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_incoming_args_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_outgoing_args_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_stack_dynamic_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_stack_vars_rtx", ",", "op", ")", ")", ")", "return", "FALSE", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "FALSE", ";", "ind", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "reload_completed", "&&", "(", "GET_CODE", "(", "ind", ")", "==", "LABEL_REF", "||", "(", "GET_CODE", "(", "ind", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "ind", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "0", ")", ")", "==", "LABEL_REF", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", ")", ")", ")", "return", "TRUE", ";", "if", "(", "GET_CODE", "(", "ind", ")", "==", "REG", ")", "return", "arm_address_register_rtx_p", "(", "ind", ",", "0", ")", ";", "if", "(", "wb", "&&", "(", "GET_CODE", "(", "ind", ")", "==", "PRE_INC", "||", "GET_CODE", "(", "ind", ")", "==", "POST_INC", "||", "GET_CODE", "(", "ind", ")", "==", "PRE_DEC", "||", "GET_CODE", "(", "ind", ")", "==", "POST_DEC", ")", ")", "return", "arm_address_register_rtx_p", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "0", ")", ";", "if", "(", "wb", "&&", "(", "GET_CODE", "(", "ind", ")", "==", "POST_MODIFY", "||", "GET_CODE", "(", "ind", ")", "==", "PRE_MODIFY", ")", "&&", "arm_address_register_rtx_p", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "0", ")", "&&", "GET_CODE", "(", "XEXP", "(", "ind", ",", "1", ")", ")", "==", "PLUS", "&&", "rtx_equal_p", "(", "XEXP", "(", "XEXP", "(", "ind", ",", "1", ")", ",", "0", ")", ",", "XEXP", "(", "ind", ",", "0", ")", ")", ")", "ind", "=", "XEXP", "(", "ind", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "ind", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "ind", ",", "0", ")", ")", "==", "REG", "&&", "REG_MODE_OK_FOR_BASE_P", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "VOIDmode", ")", "&&", "GET_CODE", "(", "XEXP", "(", "ind", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "ind", ",", "1", ")", ")", ">", "-", "1024", "&&", "INTVAL", "(", "XEXP", "(", "ind", ",", "1", ")", ")", "<", "1024", "&&", "(", "INTVAL", "(", "XEXP", "(", "ind", ",", "1", ")", ")", "&", "3", ")", "==", "0", ")", "return", "TRUE", ";", "return", "FALSE", ";", "}", "</s>" ]

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

[ "arm", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "1", "1", "0", "0", "1", "0", "0", "1", "1", "1024", "1", "1024", "1", "3", "0" ]

[]