Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "InstructionCost", "X86TTIImpl", "::", "getGatherScatterOpCost", "(", "unsigned", "Opcode", ",", "Type", "*", "SrcVTy", ",", "const", "Value", "*", "Ptr", ",", "bool", "VariableMask", ",", "Align", "Alignment", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "const", "Instruction", "*", "I", "=", "nullptr", ")", "{", "if", "(", "CostKind", "!=", "TTI", "::", "TCK_RecipThroughput", ")", "{", "if", "(", "(", "Opcode", "==", "Instruction", "::", "Load", "&&", "isLegalMaskedGather", "(", "SrcVTy", ",", "Align", "(", "Alignment", ")", ")", ")", "||", "(", "Opcode", "==", "Instruction", "::", "Store", "&&", "isLegalMaskedScatter", "(", "SrcVTy", ",", "Align", "(", "Alignment", ")", ")", ")", ")", "return", "1", ";", "return", "BaseT", "::", "getGatherScatterOpCost", "(", "Opcode", ",", "SrcVTy", ",", "Ptr", ",", "VariableMask", ",", "Alignment", ",", "CostKind", ",", "I", ")", ";", "}", "assert", "(", "SrcVTy", "->", "isVectorTy", "(", ")", "&&", "\"Unexpected data type for Gather/Scatter\"", ")", ";", "unsigned", "VF", "=", "cast", "<", "FixedVectorType", ">", "(", "SrcVTy", ")", "->", "getNumElements", "(", ")", ";", "PointerType", "*", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "Ptr", "->", "getType", "(", ")", ")", ";", "if", "(", "!", "PtrTy", "&&", "Ptr", "->", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "cast", "<", "VectorType", ">", "(", "Ptr", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ")", ";", "assert", "(", "PtrTy", "&&", "\"Unexpected type for Ptr argument\"", ")", ";", "unsigned", "AddressSpace", "=", "PtrTy", "->", "getAddressSpace", "(", ")", ";", "bool", "Scalarize", "=", "false", ";", "if", "(", "(", "Opcode", "==", "Instruction", "::", "Load", "&&", "!", "isLegalMaskedGather", "(", "SrcVTy", ",", "Align", "(", "Alignment", ")", ")", ")", "||", "(", "Opcode", "==", "Instruction", "::", "Store", "&&", "!", "isLegalMaskedScatter", "(", "SrcVTy", ",", "Align", "(", "Alignment", ")", ")", ")", ")", "Scalarize", "=", "true", ";", "if", "(", "ST", "->", "hasAVX512", "(", ")", "&&", "(", "VF", "==", "2", "||", "(", "VF", "==", "4", "&&", "!", "ST", "->", "hasVLX", "(", ")", ")", ")", ")", "Scalarize", "=", "true", ";", "if", "(", "Scalarize", ")", "return", "getGSScalarCost", "(", "Opcode", ",", "SrcVTy", ",", "VariableMask", ",", "Alignment", ",", "AddressSpace", ")", ";", "return", "getGSVectorCost", "(", "Opcode", ",", "SrcVTy", ",", "Ptr", ",", "Alignment", ",", "AddressSpace", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "Gather", "/", "Scatter", "operation", "." ]

[ "X86", "X86", "1", "\"Unexpected data type for Gather/Scatter\"", "\"Unexpected type for Ptr argument\"", "2", "4" ]

[]

[ "<s>", "static", "rtx", "frv_legitimize_tls_address", "(", "rtx", "addr", ",", "enum", "tls_model", "model", ")", "{", "rtx", "dest", ",", "tp", "=", "gen_rtx_REG", "(", "Pmode", ",", "29", ")", ";", "rtx", "picreg", "=", "get_hard_reg_initial_val", "(", "Pmode", ",", "15", ")", ";", "switch", "(", "model", ")", "{", "case", "TLS_MODEL_INITIAL_EXEC", ":", "if", "(", "flag_pic", "==", "1", ")", "{", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_tls_load_gottlsoff12", "(", "dest", ",", "addr", ",", "picreg", ")", ")", ";", "dest", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tp", ",", "dest", ")", ";", "}", "else", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_tlsoff_hilo", "(", "tmp", ",", "addr", ",", "GEN_INT", "(", "R_FRV_GOTTLSOFF_HI", ")", ")", ")", ";", "emit_insn", "(", "gen_tls_tlsoff_ld", "(", "dest", ",", "picreg", ",", "tmp", ",", "addr", ")", ")", ";", "dest", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tp", ",", "dest", ")", ";", "}", "break", ";", "case", "TLS_MODEL_LOCAL_DYNAMIC", ":", "{", "rtx", "reg", ",", "retval", ";", "if", "(", "TARGET_INLINE_PLT", ")", "retval", "=", "gen_inlined_tls_plt", "(", "GEN_INT", "(", "0", ")", ")", ";", "else", "{", "retval", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_call_gettlsoff", "(", "retval", ",", "GEN_INT", "(", "0", ")", ",", "picreg", ")", ")", ";", "}", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "retval", ",", "tp", ")", ")", ")", ";", "dest", "=", "gen_tlsmoff", "(", "addr", ",", "reg", ")", ";", "break", ";", "}", "case", "TLS_MODEL_LOCAL_EXEC", ":", "dest", "=", "gen_tlsmoff", "(", "addr", ",", "gen_rtx_REG", "(", "Pmode", ",", "29", ")", ")", ";", "break", ";", "case", "TLS_MODEL_GLOBAL_DYNAMIC", ":", "{", "rtx", "retval", ";", "if", "(", "TARGET_INLINE_PLT", ")", "retval", "=", "gen_inlined_tls_plt", "(", "addr", ")", ";", "else", "{", "retval", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_call_gettlsoff", "(", "retval", ",", "addr", ",", "picreg", ")", ")", ";", "}", "dest", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "retval", ",", "tp", ")", ";", "break", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "dest", ";", "}", "</s>" ]

[ "Generate", "code", "for", "a", "TLS", "address", "." ]

[ "frv", "29", "15", "1", "0", "0", "29" ]

[]

[ "<s>", "NodeId", "DataFlowGraph", "::", "id", "(", "const", "NodeBase", "*", "P", ")", "const", "{", "if", "(", "P", "==", "nullptr", ")", "return", "0", ";", "return", "Memory", ".", "id", "(", "P", ")", ";", "}", "</s>" ]

[ "The", "ID", "number", "of", "this", "value", "." ]

[ "Hexagon", "0" ]

[]

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

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

[ "AMDGPU", "R600" ]

[]

[ "<s>", "static", "int", "nds32_check_constant_argument", "(", "enum", "insn_code", "icode", ",", "int", "opnum", ",", "rtx", "opval", ",", "const", "char", "*", "name", ")", "{", "if", "(", "GET_CODE", "(", "opval", ")", "!=", "CONST_INT", ")", "{", "error", "(", "\"invalid argument to built-in function %s\"", ",", "name", ")", ";", "return", "false", ";", "}", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "opnum", "]", ".", "predicate", ")", "(", "opval", ",", "VOIDmode", ")", ")", "{", "error", "(", "\"constant argument out of range for %s\"", ",", "name", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "OPVAL", "can", "be", "used", "for", "operand", "OPNUM", "of", "instruction", "ICODE", ".", "The", "instruction", "should", "require", "a", "constant", "operand", "of", "some", "sort", ".", "The", "function", "prints", "an", "error", "if", "OPVAL", "is", "not", "valid", "." ]

[ "nds32", "\"invalid argument to built-in function %s\"", "\"constant argument out of range for %s\"" ]

[]

[ "<s>", "MachineInstrBuilder", "buildLoad", "(", "const", "DstOp", "&", "Res", ",", "Register", "Addr", ",", "uint64_t", "Size", ",", "MachinePointerInfo", "&", "MPO", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "auto", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOLoad", ",", "Size", ",", "inferAlignFromPtrInfo", "(", "MF", ",", "MPO", ")", ")", ";", "return", "MIRBuilder", ".", "buildLoad", "(", "Res", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

[ "Build", "and", "insert", "a", "G_LOAD", "instruction", ",", "while", "constructing", "the", "MachineMemOperand", "." ]

[ "ARM" ]

[]

[ "<s>", "const", "char", "*", "output_probe_stack_range", "(", "rtx", "reg1", ",", "rtx", "reg2", ")", "{", "static", "int", "labelno", "=", "0", ";", "char", "loop_lab", "[", "32", "]", ",", "end_lab", "[", "32", "]", ";", "rtx", "xops", "[", "2", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "loop_lab", ",", "\"LPSRL\"", ",", "labelno", ")", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "end_lab", ",", "\"LPSRE\"", ",", "labelno", "++", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "loop_lab", ")", ";", "xops", "[", "0", "]", "=", "reg1", ";", "xops", "[", "1", "]", "=", "reg2", ";", "output_asm_insn", "(", "\"cmp\\t%0, %1\"", ",", "xops", ")", ";", "if", "(", "TARGET_ARCH64", ")", "fputs", "(", "\"\\tbe,pn\\t%xcc,\"", ",", "asm_out_file", ")", ";", "else", "fputs", "(", "\"\\tbe\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "end_lab", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "xops", "[", "1", "]", "=", "GEN_INT", "(", "-", "PROBE_INTERVAL", ")", ";", "output_asm_insn", "(", "\" add\\t%0, %1, %0\"", ",", "xops", ")", ";", "if", "(", "TARGET_ARCH64", ")", "fputs", "(", "\"\\tba,pt\\t%xcc,\"", ",", "asm_out_file", ")", ";", "else", "fputs", "(", "\"\\tba\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "loop_lab", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "xops", "[", "1", "]", "=", "GEN_INT", "(", "SPARC_STACK_BIAS", ")", ";", "output_asm_insn", "(", "\" st\\t%%g0, [%0+%1]\"", ",", "xops", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "end_lab", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

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

[ "sparc", "0", "32", "32", "2", "\"LPSRL\"", "\"LPSRE\"", "0", "1", "\"cmp\\t%0, %1\"", "\"\\tbe,pn\\t%xcc,\"", "\"\\tbe\\t\"", "1", "\" add\\t%0, %1, %0\"", "\"\\tba,pt\\t%xcc,\"", "\"\\tba\\t\"", "1", "\" st\\t%%g0, [%0+%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_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 \"", "\"CBCOND \"", "\"DEPRECATED_V8_INSNS \"", "\"SPARCLET \"", "\"SPARCLITE \"", "\"V8 \"", "\"V9 \"" ]

[]

[ "<s>", "int", "mmix_extra_constraint", "(", "rtx", "x", ",", "int", "c", ",", "int", "strict", ")", "{", "HOST_WIDEST_INT", "value", ";", "if", "(", "c", "==", "'U'", ")", "return", "strict", "?", "strict_memory_address_p", "(", "Pmode", ",", "x", ")", ":", "memory_address_p", "(", "Pmode", ",", "x", ")", ";", "if", "(", "c", "==", "'R'", ")", "return", "GET_CODE", "(", "x", ")", "!=", "CONST_INT", "&&", "GET_CODE", "(", "x", ")", "!=", "CONST_DOUBLE", "&&", "mmix_constant_address_p", "(", "x", ")", "&&", "(", "!", "TARGET_BASE_ADDRESSES", "||", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", "||", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_FLAG", "(", "x", ")", ")", ")", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "CONST_DOUBLE", "||", "GET_MODE", "(", "x", ")", "!=", "VOIDmode", ")", "return", "0", ";", "value", "=", "mmix_intval", "(", "x", ")", ";", "if", "(", "c", "==", "'S'", ")", "return", "mmix_shiftable_wyde_value", "(", "value", ")", ";", "else", "if", "(", "c", "==", "'T'", ")", "return", "mmix_shiftable_wyde_value", "(", "~", "value", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "EXTRA_CONSTRAINT", ".", "We", "need", "this", "since", "our", "constants", "are", "not", "always", "expressible", "as", "CONST_INT", ":", "s", ",", "but", "rather", "often", "as", "CONST_DOUBLE", ":", "s", "." ]

[ "mmix", "0", "0" ]

[]

[ "<s>", "SDNode", "*", "SITargetLowering", "::", "legalizeTargetIndependentNode", "(", "SDNode", "*", "Node", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Node", "->", "getOpcode", "(", ")", "==", "ISD", "::", "CopyToReg", ")", "{", "RegisterSDNode", "*", "DestReg", "=", "cast", "<", "RegisterSDNode", ">", "(", "Node", "->", "getOperand", "(", "1", ")", ")", ";", "SDValue", "SrcVal", "=", "Node", "->", "getOperand", "(", "2", ")", ";", "if", "(", "SrcVal", ".", "getValueType", "(", ")", "==", "MVT", "::", "i1", "&&", "DestReg", "->", "getReg", "(", ")", ".", "isPhysical", "(", ")", ")", "{", "SDLoc", "SL", "(", "Node", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ";", "SDValue", "VReg", "=", "DAG", ".", "getRegister", "(", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "VReg_1RegClass", ")", ",", "MVT", "::", "i1", ")", ";", "SDNode", "*", "Glued", "=", "Node", "->", "getGluedNode", "(", ")", ";", "SDValue", "ToVReg", "=", "DAG", ".", "getCopyToReg", "(", "Node", "->", "getOperand", "(", "0", ")", ",", "SL", ",", "VReg", ",", "SrcVal", ",", "SDValue", "(", "Glued", ",", "Glued", "?", "Glued", "->", "getNumValues", "(", ")", "-", "1", ":", "0", ")", ")", ";", "SDValue", "ToResultReg", "=", "DAG", ".", "getCopyToReg", "(", "ToVReg", ",", "SL", ",", "SDValue", "(", "DestReg", ",", "0", ")", ",", "VReg", ",", "ToVReg", ".", "getValue", "(", "1", ")", ")", ";", "DAG", ".", "ReplaceAllUsesWith", "(", "Node", ",", "ToResultReg", ".", "getNode", "(", ")", ")", ";", "DAG", ".", "RemoveDeadNode", "(", "Node", ")", ";", "return", "ToResultReg", ".", "getNode", "(", ")", ";", "}", "}", "SmallVector", "<", "SDValue", ",", "8", ">", "Ops", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Node", "->", "getNumOperands", "(", ")", ";", "++", "i", ")", "{", "if", "(", "!", "isFrameIndexOp", "(", "Node", "->", "getOperand", "(", "i", ")", ")", ")", "{", "Ops", ".", "push_back", "(", "Node", "->", "getOperand", "(", "i", ")", ")", ";", "continue", ";", "}", "SDLoc", "DL", "(", "Node", ")", ";", "Ops", ".", "push_back", "(", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "AMDGPU", "::", "S_MOV_B32", ",", "DL", ",", "Node", "->", "getOperand", "(", "i", ")", ".", "getValueType", "(", ")", ",", "Node", "->", "getOperand", "(", "i", ")", ")", ",", "0", ")", ")", ";", "}", "return", "DAG", ".", "UpdateNodeOperands", "(", "Node", ",", "Ops", ")", ";", "}", "</s>" ]

[ "Legalize", "target", "independent", "instructions", "(", "e.g", "." ]

[ "AMDGPU", "SI", "ISD::CopyToReg", "1", "2", "MVT::i1", "AMDGPU::VReg_1RegClass", "MVT::i1", "0", "1", "0", "0", "1", "8", "0", "AMDGPU::S_MOV_B32", "0" ]

[]

[ "<s>", "static", "void", "arm_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", "ATTRIBUTE_UNUSED", ",", "tree", "function", ")", "{", "static", "int", "thunk_label", "=", "0", ";", "char", "label", "[", "256", "]", ";", "int", "mi_delta", "=", "delta", ";", "const", "char", "*", "const", "mi_op", "=", "mi_delta", "<", "0", "?", "\"sub\"", ":", "\"add\"", ";", "int", "shift", "=", "0", ";", "int", "this_regno", "=", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", "?", "1", ":", "0", ")", ";", "if", "(", "mi_delta", "<", "0", ")", "mi_delta", "=", "-", "mi_delta", ";", "if", "(", "TARGET_THUMB", ")", "{", "int", "labelno", "=", "thunk_label", "++", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "label", ",", "\"LTHUMBFUNC\"", ",", "labelno", ")", ";", "fputs", "(", "\"\\tldr\\tr12, \"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "label", ")", ";", "fputc", "(", "'\\n'", ",", "file", ")", ";", "}", "while", "(", "mi_delta", "!=", "0", ")", "{", "if", "(", "(", "mi_delta", "&", "(", "3", "<<", "shift", ")", ")", "==", "0", ")", "shift", "+=", "2", ";", "else", "{", "asm_fprintf", "(", "file", ",", "\"\\t%s\\t%r, %r, #%d\\n\"", ",", "mi_op", ",", "this_regno", ",", "this_regno", ",", "mi_delta", "&", "(", "0xff", "<<", "shift", ")", ")", ";", "mi_delta", "&=", "~", "(", "0xff", "<<", "shift", ")", ";", "shift", "+=", "8", ";", "}", "}", "if", "(", "TARGET_THUMB", ")", "{", "fprintf", "(", "file", ",", "\"\\tbx\\tr12\\n\"", ")", ";", "ASM_OUTPUT_ALIGN", "(", "file", ",", "2", ")", ";", "assemble_name", "(", "file", ",", "label", ")", ";", "fputs", "(", "\":\\n\"", ",", "file", ")", ";", "assemble_integer", "(", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ",", "4", ",", "BITS_PER_WORD", ",", "1", ")", ";", "}", "else", "{", "fputs", "(", "\"\\tb\\t\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ",", "0", ")", ")", ";", "if", "(", "NEED_PLT_RELOC", ")", "fputs", "(", "\"(PLT)\"", ",", "file", ")", ";", "fputc", "(", "'\\n'", ",", "file", ")", ";", "}", "}", "</s>" ]

[ "Output", "code", "to", "add", "DELTA", "to", "the", "first", "argument", ",", "and", "then", "jump", "to", "FUNCTION", ".", "Used", "for", "C++", "multiple", "inheritance", "." ]

[ "arm", "0", "256", "0", "\"sub\"", "\"add\"", "0", "1", "0", "0", "\"LTHUMBFUNC\"", "\"\\tldr\\tr12, \"", "0", "3", "0", "2", "\"\\t%s\\t%r, %r, #%d\\n\"", "0xff", "0xff", "8", "\"\\tbx\\tr12\\n\"", "2", "\":\\n\"", "0", "4", "1", "\"\\tb\\t\"", "0", "0", "\"(PLT)\"" ]

[]

[ "<s>", "NyuziTargetLowering", "::", "ConstraintType", "NyuziTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'s'", ":", "case", "'r'", ":", "case", "'v'", ":", "return", "C_RegisterClass", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi", "Nyuzi", "1", "0" ]

[]

[ "<s>", "static", "int", "ia64_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "int", "dep_type1", ",", "rtx_insn", "*", "dep_insn", ",", "int", "cost", ",", "dw_t", "dw", ")", "{", "enum", "reg_note", "dep_type", "=", "(", "enum", "reg_note", ")", "dep_type1", ";", "enum", "attr_itanium_class", "dep_class", ";", "enum", "attr_itanium_class", "insn_class", ";", "insn_class", "=", "ia64_safe_itanium_class", "(", "insn", ")", ";", "dep_class", "=", "ia64_safe_itanium_class", "(", "dep_insn", ")", ";", "if", "(", "dep_type", "==", "REG_DEP_TRUE", "&&", "(", "dep_class", "==", "ITANIUM_CLASS_ST", "||", "dep_class", "==", "ITANIUM_CLASS_STF", ")", "&&", "(", "insn_class", "==", "ITANIUM_CLASS_BR", "||", "insn_class", "==", "ITANIUM_CLASS_SCALL", ")", ")", "return", "0", ";", "if", "(", "dw", "==", "MIN_DEP_WEAK", ")", "return", "PARAM_VALUE", "(", "PARAM_SCHED_MEM_TRUE_DEP_COST", ")", ";", "else", "if", "(", "dw", ">", "MIN_DEP_WEAK", ")", "{", "if", "(", "mflag_sched_fp_mem_deps_zero_cost", "&&", "dep_class", "==", "ITANIUM_CLASS_STF", ")", "return", "0", ";", "else", "return", "cost", ";", "}", "if", "(", "dep_type", "!=", "REG_DEP_OUTPUT", ")", "return", "cost", ";", "if", "(", "dep_class", "==", "ITANIUM_CLASS_ST", "||", "dep_class", "==", "ITANIUM_CLASS_STF", "||", "insn_class", "==", "ITANIUM_CLASS_ST", "||", "insn_class", "==", "ITANIUM_CLASS_STF", ")", "return", "0", ";", "return", "cost", ";", "}", "</s>" ]

[ "Adjust", "the", "cost", "of", "a", "scheduling", "dependency", ".", "Return", "the", "new", "cost", "of", "a", "dependency", "LINK", "or", "INSN", "on", "DEP_INSN", ".", "COST", "is", "the", "current", "cost", "." ]

[ "ia64", "0", "0", "0" ]

[]

[ "<s>", "NVPTXSubtarget", "::", "NVPTXSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ",", "bool", "is64Bit", ")", ":", "NVPTXGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "Is64Bit", "(", "is64Bit", ")", ",", "PTXVersion", "(", "0", ")", ",", "SmVersion", "(", "20", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "(", "const", "NVPTXTargetMachine", "&", ")", "TM", ",", "*", "this", ")", ",", "TSInfo", "(", "TM", ".", "getDataLayout", "(", ")", ")", ",", "FrameLowering", "(", "*", "this", ")", "{", "Triple", "T", "(", "TT", ")", ";", "if", "(", "T", ".", "getOS", "(", ")", "==", "Triple", "::", "NVCL", ")", "drvInterface", "=", "NVPTX", "::", "NVCL", ";", "else", "drvInterface", "=", "NVPTX", "::", "CUDA", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX", "NVPTX", "0", "20", "NVPTX", "NVPTX::NVCL", "NVPTX::CUDA" ]

[]

[ "<s>", "static", "bool", "has_non_address_hard_reg", "(", "rtx_insn", "*", "insn", ")", "{", "df_ref", "ref", ";", "FOR_EACH_INSN_DEF", "(", "ref", ",", "insn", ")", "if", "(", "HARD_REGISTER_P", "(", "DF_REF_REAL_REG", "(", "ref", ")", ")", "&&", "!", "DF_REF_FLAGS_IS_SET", "(", "ref", ",", "DF_REF_MUST_CLOBBER", ")", "&&", "DF_REF_REGNO", "(", "ref", ")", "!=", "FLAGS_REG", ")", "return", "true", ";", "FOR_EACH_INSN_USE", "(", "ref", ",", "insn", ")", "if", "(", "!", "DF_REF_REG_MEM_P", "(", "ref", ")", "&&", "HARD_REGISTER_P", "(", "DF_REF_REAL_REG", "(", "ref", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "1", "if", "INSN", "uses", "or", "defines", "a", "hard", "register", ".", "Hard", "register", "uses", "in", "a", "memory", "address", "are", "ignored", ".", "Clobbers", "and", "flags", "definitions", "are", "ignored", "." ]

[ "i386" ]

[]

[ "<s>", "SDNode", "*", "LC3DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "Constant", ":", "return", "SelectMoveImmediate", "(", "N", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "SelectConditionalBranch", "(", "N", ")", ";", "}", "return", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "LC3", "LC3", "ISD::Constant", "ISD::BR_CC" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isPredicable", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "!", "MI", ".", "getDesc", "(", ")", ".", "isPredicable", "(", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "isCall", "(", ")", "||", "isTailCall", "(", "MI", ")", ")", "{", "if", "(", "!", "Subtarget", ".", "usePredicatedCalls", "(", ")", ")", "return", "false", ";", "}", "if", "(", "!", "Subtarget", ".", "hasV62TOps", "(", ")", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Hexagon", "::", "V6_vL32b_ai", ":", "case", "Hexagon", "::", "V6_vL32b_pi", ":", "case", "Hexagon", "::", "V6_vL32b_ppu", ":", "case", "Hexagon", "::", "V6_vL32b_cur_ai", ":", "case", "Hexagon", "::", "V6_vL32b_cur_pi", ":", "case", "Hexagon", "::", "V6_vL32b_cur_ppu", ":", "case", "Hexagon", "::", "V6_vL32b_nt_ai", ":", "case", "Hexagon", "::", "V6_vL32b_nt_pi", ":", "case", "Hexagon", "::", "V6_vL32b_nt_ppu", ":", "case", "Hexagon", "::", "V6_vL32b_tmp_ai", ":", "case", "Hexagon", "::", "V6_vL32b_tmp_pi", ":", "case", "Hexagon", "::", "V6_vL32b_tmp_ppu", ":", "case", "Hexagon", "::", "V6_vL32b_nt_cur_ai", ":", "case", "Hexagon", "::", "V6_vL32b_nt_cur_pi", ":", "case", "Hexagon", "::", "V6_vL32b_nt_cur_ppu", ":", "case", "Hexagon", "::", "V6_vL32b_nt_tmp_ai", ":", "case", "Hexagon", "::", "V6_vL32b_nt_tmp_pi", ":", "case", "Hexagon", "::", "V6_vL32b_nt_tmp_ppu", ":", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

[ "Hexagon", "Hexagon", "Hexagon::V6_vL32b_ai", "Hexagon::V6_vL32b_pi", "Hexagon::V6_vL32b_ppu", "Hexagon::V6_vL32b_cur_ai", "Hexagon::V6_vL32b_cur_pi", "Hexagon::V6_vL32b_cur_ppu", "Hexagon::V6_vL32b_nt_ai", "Hexagon::V6_vL32b_nt_pi", "Hexagon::V6_vL32b_nt_ppu", "Hexagon::V6_vL32b_tmp_ai", "Hexagon::V6_vL32b_tmp_pi", "Hexagon::V6_vL32b_tmp_ppu", "Hexagon::V6_vL32b_nt_cur_ai", "Hexagon::V6_vL32b_nt_cur_pi", "Hexagon::V6_vL32b_nt_cur_ppu", "Hexagon::V6_vL32b_nt_tmp_ai", "Hexagon::V6_vL32b_nt_tmp_pi", "Hexagon::V6_vL32b_nt_tmp_ppu" ]

[]

[ "<s>", "static", "rtx_insn", "*", "rs6000_emit_savres_rtx", "(", "rs6000_stack_t", "*", "info", ",", "rtx", "frame_reg_rtx", ",", "int", "save_area_offset", ",", "int", "lr_offset", ",", "machine_mode", "reg_mode", ",", "int", "sel", ")", "{", "int", "i", ";", "int", "offset", ",", "start_reg", ",", "end_reg", ",", "n_regs", ",", "use_reg", ";", "int", "reg_size", "=", "GET_MODE_SIZE", "(", "reg_mode", ")", ";", "rtx", "sym", ";", "rtvec", "p", ";", "rtx", "par", ";", "rtx_insn", "*", "insn", ";", "offset", "=", "0", ";", "start_reg", "=", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_GPR", "?", "info", "->", "first_gp_reg_save", ":", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_FPR", "?", "info", "->", "first_fp_reg_save", ":", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_VR", "?", "info", "->", "first_altivec_reg_save", ":", "-", "1", ")", ";", "end_reg", "=", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_GPR", "?", "32", ":", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_FPR", "?", "64", ":", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_VR", "?", "LAST_ALTIVEC_REGNO", "+", "1", ":", "-", "1", ")", ";", "n_regs", "=", "end_reg", "-", "start_reg", ";", "p", "=", "rtvec_alloc", "(", "3", "+", "(", "(", "sel", "&", "SAVRES_LR", ")", "?", "1", ":", "0", ")", "+", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_VR", "?", "1", ":", "0", ")", "+", "n_regs", ")", ";", "if", "(", "!", "(", "sel", "&", "SAVRES_SAVE", ")", "&&", "(", "sel", "&", "SAVRES_LR", ")", ")", "RTVEC_ELT", "(", "p", ",", "offset", "++", ")", "=", "ret_rtx", ";", "RTVEC_ELT", "(", "p", ",", "offset", "++", ")", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "LR_REGNO", ")", ")", ";", "sym", "=", "rs6000_savres_routine_sym", "(", "info", ",", "sel", ")", ";", "RTVEC_ELT", "(", "p", ",", "offset", "++", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "sym", ")", ";", "use_reg", "=", "ptr_regno_for_savres", "(", "sel", ")", ";", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_VR", ")", "{", "RTVEC_ELT", "(", "p", ",", "offset", "++", ")", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "use_reg", ")", ")", ";", "RTVEC_ELT", "(", "p", ",", "offset", "++", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ")", ";", "}", "else", "RTVEC_ELT", "(", "p", ",", "offset", "++", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "use_reg", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "end_reg", "-", "start_reg", ";", "i", "++", ")", "RTVEC_ELT", "(", "p", ",", "i", "+", "offset", ")", "=", "gen_frame_set", "(", "gen_rtx_REG", "(", "reg_mode", ",", "start_reg", "+", "i", ")", ",", "frame_reg_rtx", ",", "save_area_offset", "+", "reg_size", "*", "i", ",", "(", "sel", "&", "SAVRES_SAVE", ")", "!=", "0", ")", ";", "if", "(", "(", "sel", "&", "SAVRES_SAVE", ")", "&&", "(", "sel", "&", "SAVRES_LR", ")", ")", "RTVEC_ELT", "(", "p", ",", "i", "+", "offset", ")", "=", "gen_frame_store", "(", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ",", "frame_reg_rtx", ",", "lr_offset", ")", ";", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "p", ")", ";", "if", "(", "!", "(", "sel", "&", "SAVRES_SAVE", ")", "&&", "(", "sel", "&", "SAVRES_LR", ")", ")", "{", "insn", "=", "emit_jump_insn", "(", "par", ")", ";", "JUMP_LABEL", "(", "insn", ")", "=", "ret_rtx", ";", "}", "else", "insn", "=", "emit_insn", "(", "par", ")", ";", "return", "insn", ";", "}", "</s>" ]

[ "Construct", "a", "parallel", "rtx", "describing", "the", "effect", "of", "a", "call", "to", "an", "out-of-line", "register", "save/restore", "routine", ",", "and", "emit", "the", "insn", "or", "jump_insn", "as", "appropriate", "." ]

[ "powerpcspe", "0", "1", "32", "64", "1", "1", "3", "1", "0", "1", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "rl78_register_pragmas", "(", "void", ")", "{", "c_register_addr_space", "(", "\"__near\"", ",", "ADDR_SPACE_NEAR", ")", ";", "c_register_addr_space", "(", "\"__far\"", ",", "ADDR_SPACE_FAR", ")", ";", "}", "</s>" ]

[ "Implements", "REGISTER_TARGET_PRAGMAS", "." ]

[ "rl78", "\"__near\"", "\"__far\"" ]

[]

[ "<s>", "bool", "MipsAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "if", "(", "requestsDoubleOperand", "(", "Name", ")", ")", "{", "setFpFormat", "(", "FP_FORMAT_D", ")", ";", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "}", "else", "{", "setDefaultFpFormat", "(", ")", ";", "size_t", "Start", "=", "0", ",", "Next", "=", "Name", ".", "find", "(", "'.'", ")", ";", "StringRef", "Mnemonic", "=", "Name", ".", "slice", "(", "Start", ",", "Next", ")", ";", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateToken", "(", "Mnemonic", ",", "NameLoc", ")", ")", ";", "if", "(", "Next", "!=", "StringRef", "::", "npos", ")", "{", "size_t", "Dot", "=", "Name", ".", "find", "(", "'.'", ",", "Next", "+", "1", ")", ";", "StringRef", "Format", "=", "Name", ".", "slice", "(", "Next", ",", "Dot", ")", ";", "if", "(", "Dot", "==", "StringRef", "::", "npos", ")", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateToken", "(", "Format", ",", "NameLoc", ")", ")", ";", "else", "{", "if", "(", "Name", ".", "startswith", "(", "\"c.\"", ")", ")", "{", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateToken", "(", "\".\"", ",", "NameLoc", ")", ")", ";", "int", "Cc", "=", "ConvertCcString", "(", "Format", ")", ";", "if", "(", "Cc", "==", "-", "1", ")", "{", "return", "Error", "(", "NameLoc", ",", "\"Invalid conditional code\"", ")", ";", "}", "SMLoc", "E", "=", "SMLoc", "::", "getFromPointer", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ".", "getPointer", "(", ")", "-", "1", ")", ";", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateImm", "(", "MCConstantExpr", "::", "Create", "(", "Cc", ",", "getContext", "(", ")", ")", ",", "NameLoc", ",", "E", ")", ")", ";", "}", "else", "{", "return", "parseMathOperation", "(", "Name", ",", "NameLoc", ",", "Operands", ")", ";", "}", "Format", "=", "Name", ".", "slice", "(", "Dot", ",", "StringRef", "::", "npos", ")", ";", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateToken", "(", "Format", ",", "NameLoc", ")", ")", ";", "}", "setFpFormat", "(", "Format", ")", ";", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "ParseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "EatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "ParseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "EatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "EatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "Mips", "Mips", "MipsOperand::CreateToken", "0", "MipsOperand::CreateToken", "1", "MipsOperand::CreateToken", "\"c.\"", "MipsOperand::CreateToken", "\".\"", "1", "\"Invalid conditional code\"", "1", "MipsOperand::CreateImm", "MipsOperand::CreateToken", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"" ]

[]

[ "<s>", "void", "emitLabel", "(", "MCSymbol", "*", "Symbol", ",", "SMLoc", "Loc", "=", "SMLoc", "(", ")", ")", "override", "{", "if", "(", "Symbol", "->", "isUndefined", "(", ")", ")", "return", ";", "assert", "(", "getCurrentSection", "(", ")", ".", "first", "&&", "\"Cannot emit before setting section!\"", ")", ";", "AssignFragment", "(", "Symbol", ",", "&", "getCurrentSection", "(", ")", ".", "first", "->", "getDummyFragment", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "label", "for", "Symbol", "into", "the", "current", "section", "." ]

[ "Patmos", "\"Cannot emit before setting section!\"" ]

[]

[ "<s>", "static", "int", "rs6000_get_some_local_dynamic_name_1", "(", "rtx", "*", "px", ",", "void", "*", "data", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "x", "=", "*", "px", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "{", "const", "char", "*", "str", "=", "XSTR", "(", "x", ",", "0", ")", ";", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "TLS_MODEL_LOCAL_DYNAMIC", ")", "{", "cfun", "->", "machine", "->", "some_ld_name", "=", "str", ";", "return", "1", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "x86_elf_aligned_common", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "int", "align", ")", "{", "if", "(", "(", "ix86_cmodel", "==", "CM_MEDIUM", "||", "ix86_cmodel", "==", "CM_MEDIUM_PIC", ")", "&&", "size", ">", "(", "unsigned", "int", ")", "ix86_section_threshold", ")", "fprintf", "(", "file", ",", "\".largecomm\\t\"", ")", ";", "else", "fprintf", "(", "file", ",", "\"%s\"", ",", "COMMON_ASM_OP", ")", ";", "assemble_name", "(", "file", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\",\"", "HOST_WIDE_INT_PRINT_UNSIGNED", "\",%u\\n\"", ",", "size", ",", "align", "/", "BITS_PER_UNIT", ")", ";", "}", "</s>" ]

[ "This", "says", "how", "to", "output", "assembler", "code", "to", "declare", "an", "uninitialized", "external", "linkage", "data", "object", ".", "For", "medium", "model", "x86-64", "we", "need", "to", "use", ".largecomm", "opcode", "for", "large", "objects", "." ]

[ "i386", "\".largecomm\\t\"", "\"%s\"", "\",\"", "\",%u\\n\"" ]

[]

[ "<s>", "bool", "SIInsertSkips", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "SkipThreshold", "=", "SkipThresholdFlag", ";", "SmallVector", "<", "MachineInstr", "*", ",", "4", ">", "KillInstrs", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_MASK_BRANCH", ":", "MadeChange", "|=", "skipMaskBranch", "(", "MI", ",", "MBB", ")", ";", "break", ";", "case", "AMDGPU", "::", "S_BRANCH", ":", "if", "(", "MBB", ".", "isLayoutSuccessor", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ")", "{", "assert", "(", "&", "MI", "==", "&", "MBB", ".", "back", "(", ")", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "MadeChange", "=", "true", ";", "}", "break", ";", "case", "AMDGPU", "::", "SI_KILL_F32_COND_IMM_TERMINATOR", ":", "case", "AMDGPU", "::", "SI_KILL_I1_TERMINATOR", ":", "{", "MadeChange", "=", "true", ";", "bool", "CanKill", "=", "kill", "(", "MI", ")", ";", "if", "(", "CanKill", "&&", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AMDGPU_PS", "&&", "dominatesAllReachable", "(", "MBB", ")", ")", "{", "KillInstrs", ".", "push_back", "(", "&", "MI", ")", ";", "}", "else", "{", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "break", ";", "}", "case", "AMDGPU", "::", "SI_KILL_CLEANUP", ":", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AMDGPU_PS", "&&", "dominatesAllReachable", "(", "MBB", ")", ")", "{", "KillInstrs", ".", "push_back", "(", "&", "MI", ")", ";", "}", "else", "{", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "break", ";", "default", ":", "break", ";", "}", "}", "}", "for", "(", "MachineInstr", "*", "Kill", ":", "KillInstrs", ")", "{", "skipIfDead", "(", "*", "Kill", "->", "getParent", "(", ")", ",", "std", "::", "next", "(", "Kill", "->", "getIterator", "(", ")", ")", ",", "Kill", "->", "getDebugLoc", "(", ")", ")", ";", "Kill", "->", "eraseFromParent", "(", ")", ";", "}", "KillInstrs", ".", "clear", "(", ")", ";", "EarlyExitBlock", "=", "nullptr", ";", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "4", "AMDGPU::SI_MASK_BRANCH", "AMDGPU::S_BRANCH", "0", "AMDGPU::SI_KILL_F32_COND_IMM_TERMINATOR", "AMDGPU::SI_KILL_I1_TERMINATOR", "AMDGPU", "AMDGPU::SI_KILL_CLEANUP", "AMDGPU" ]

[]

[ "<s>", "MachineBasicBlock", "*", "FISCTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "BB", "->", "getParent", "(", ")", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "MI", "->", "getOpcode", "(", ")", "==", "FISC", "::", "Select", "&&", "\"Unexpected instr type to insert\"", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "I", "=", "++", "BB", "->", "getIterator", "(", ")", ";", "MachineBasicBlock", "*", "ThisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "Copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "Copy1MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "I", ",", "Copy0MBB", ")", ";", "F", "->", "insert", "(", "I", ",", "Copy1MBB", ")", ";", "Copy1MBB", "->", "splice", "(", "Copy1MBB", "->", "begin", "(", ")", ",", "BB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "Copy1MBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "Copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "Copy1MBB", ")", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", ".", "get", "(", "FISC", "::", "Bcc", ")", ")", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "3", ")", ")", ".", "addMBB", "(", "Copy1MBB", ",", "FISCII", "::", "MO_CALL19", ")", ";", "BB", "=", "Copy0MBB", ";", "BB", "->", "addSuccessor", "(", "Copy1MBB", ")", ";", "BB", "=", "Copy1MBB", ";", "BuildMI", "(", "*", "BB", ",", "BB", "->", "begin", "(", ")", ",", "DL", ",", "TII", ".", "get", "(", "FISC", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "Copy0MBB", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "ThisMBB", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "BB", ";", "}", "</s>" ]

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

[ "FISC", "FISC", "FISC::Select", "\"Unexpected instr type to insert\"", "FISC::Bcc", "3", "FISCII::MO_CALL19", "FISC::PHI", "0", "2", "1" ]

[]

[ "<s>", "static", "bool", "tryAddingSymbolicOperand", "(", "int64_t", "Value", ",", "bool", "isBranch", ",", "uint64_t", "Address", ",", "uint64_t", "Offset", ",", "uint64_t", "Width", ",", "MCInst", "&", "MI", ",", "const", "MCDisassembler", "*", "Decoder", ")", "{", "return", "Decoder", "->", "tryAddingSymbolicOperand", "(", "MI", ",", "Value", ",", "Address", ",", "isBranch", ",", "Offset", ",", "Width", ")", ";", "}", "</s>" ]

[ "Try", "to", "add", "a", "symbolic", "operand", "instead", "of", "Value", "to", "the", "MCInst", "." ]

[ "SystemZ" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "hasReservedSpillSlot", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Reg", ",", "int", "&", "FrameIdx", ")", "const", "{", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "PPC", "::", "CR2", "<=", "Reg", "&&", "Reg", "<=", "PPC", "::", "CR4", ")", "{", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "{", "FrameIdx", "=", "0", ";", "}", "else", "if", "(", "CRSpillFrameIdx", ")", "{", "FrameIdx", "=", "CRSpillFrameIdx", ";", "}", "else", "{", "MachineFrameInfo", "*", "MFI", "=", "(", "(", "MachineFunction", "&", ")", "MF", ")", ".", "getFrameInfo", "(", ")", ";", "FrameIdx", "=", "MFI", "->", "CreateFixedObject", "(", "(", "uint64_t", ")", "4", ",", "(", "int64_t", ")", "-", "4", ",", "true", ")", ";", "CRSpillFrameIdx", "=", "FrameIdx", ";", "}", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "target", "has", "reserved", "a", "spill", "slot", "in", "the", "stack", "frame", "of", "the", "given", "function", "for", "the", "specified", "register", "." ]

[ "PowerPC", "PPC", "PPC::CR2", "PPC::CR4", "PPC", "0", "4", "4" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "BuildCFI", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "const", "MCCFIInstruction", "&", "CFIInst", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "getMMI", "(", ")", ".", "addFrameInst", "(", "CFIInst", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "</s>" ]

[ "Wraps", "up", "getting", "a", "CFI", "index", "and", "building", "a", "MachineInstr", "for", "it", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "LanaiAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "case", "'H'", ":", "{", "if", "(", "OpNo", "==", "0", ")", "return", "true", ";", "const", "MachineOperand", "&", "FlagsOP", "=", "MI", "->", "getOperand", "(", "OpNo", "-", "1", ")", ";", "if", "(", "!", "FlagsOP", ".", "isImm", "(", ")", ")", "return", "true", ";", "unsigned", "Flags", "=", "FlagsOP", ".", "getImm", "(", ")", ";", "unsigned", "NumVals", "=", "InlineAsm", "::", "getNumOperandRegisters", "(", "Flags", ")", ";", "if", "(", "NumVals", "!=", "2", ")", "return", "true", ";", "unsigned", "RegOp", "=", "OpNo", "+", "1", ";", "if", "(", "RegOp", ">=", "MI", "->", "getNumOperands", "(", ")", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "RegOp", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "return", "true", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "O", "<<", "LanaiInstPrinter", "::", "getRegisterName", "(", "Reg", ")", ";", "return", "false", ";", "}", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "O", ")", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "0", "1", "0", "0", "1", "2", "1", "Lanai" ]

[]

[ "<s>", "void", "BPFAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_4", "||", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_8", ")", "{", "assert", "(", "Value", "==", "0", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_4", ")", "{", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "]", ",", "Value", ",", "Endian", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_8", ")", "{", "support", "::", "endian", "::", "write", "<", "uint64_t", ">", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "]", ",", "Value", ",", "Endian", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_4", ")", "{", "Value", "=", "(", "uint32_t", ")", "(", "(", "Value", "-", "8", ")", "/", "8", ")", ";", "if", "(", "Endian", "==", "support", "::", "little", ")", "{", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "1", "]", "=", "0x10", ";", "support", "::", "endian", "::", "write32le", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "4", "]", ",", "Value", ")", ";", "}", "else", "{", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "1", "]", "=", "0x1", ";", "support", "::", "endian", "::", "write32be", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "4", "]", ",", "Value", ")", ";", "}", "}", "else", "{", "assert", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_2", ")", ";", "Value", "=", "(", "uint16_t", ")", "(", "(", "Value", "-", "8", ")", "/", "8", ")", ";", "support", "::", "endian", "::", "write", "<", "uint16_t", ">", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "2", "]", ",", "Value", ",", "Endian", ")", ";", "}", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "BPF", "BPF", "0", "support::endian", "support::endian", "8", "8", "support::little", "1", "0x10", "support::endian", "4", "1", "0x1", "support::endian", "4", "8", "8", "support::endian", "2" ]

[]

[ "<s>", "bool", "MipsInstrInfo", "::", "SafeInFPUDelaySlot", "(", "const", "MachineInstr", "&", "MIInSlot", ",", "const", "MachineInstr", "&", "FPUMI", ")", "const", "{", "if", "(", "MIInSlot", ".", "isInlineAsm", "(", ")", ")", "return", "false", ";", "if", "(", "HasFPUDelaySlot", "(", "MIInSlot", ")", ")", "return", "false", ";", "switch", "(", "MIInSlot", ".", "getOpcode", "(", ")", ")", "{", "case", "Mips", "::", "BC1F", ":", "case", "Mips", "::", "BC1FL", ":", "case", "Mips", "::", "BC1T", ":", "case", "Mips", "::", "BC1TL", ":", "return", "false", ";", "}", "for", "(", "const", "MachineOperand", "&", "Op", ":", "FPUMI", ".", "defs", "(", ")", ")", "{", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "continue", ";", "bool", "Reads", ",", "Writes", ";", "std", "::", "tie", "(", "Reads", ",", "Writes", ")", "=", "MIInSlot", ".", "readsWritesVirtualRegister", "(", "Op", ".", "getReg", "(", ")", ")", ";", "if", "(", "Reads", "||", "Writes", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Predicate", "to", "determine", "if", "an", "instruction", "can", "go", "in", "an", "FPU", "delay", "slot", "." ]

[ "Mips", "Mips", "Mips::BC1F", "Mips::BC1FL", "Mips::BC1T", "Mips::BC1TL" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "ARCRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CSR_ARC_SaveList", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "ARC" ]

[]

[ "<s>", "void", "MetadataStreamer", "::", "dump", "(", "StringRef", "HSAMetadataString", ")", "const", "{", "errs", "(", ")", "<<", "\"AMDGPU HSA Metadata:\\n\"", "<<", "HSAMetadataString", "<<", "'\\n'", ";", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "AMDGPU", "\"AMDGPU HSA Metadata:\\n\"" ]

[]

[ "<s>", "bool", "Z80RegisterInfo", "::", "shouldCoalesce", "(", "MachineInstr", "*", "MI", ",", "const", "TargetRegisterClass", "*", "SrcRC", ",", "unsigned", "SrcSubReg", ",", "const", "TargetRegisterClass", "*", "DstRC", ",", "unsigned", "DstSubReg", ",", "const", "TargetRegisterClass", "*", "NewRC", ",", "LiveIntervals", "&", "LIS", ")", "const", "{", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ".", "getTargetRegisterInfo", "(", ")", ";", "(", "void", ")", "TRI", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "TRI", ".", "getRegClassName", "(", "SrcRC", ")", "<<", "'['", "<<", "SrcRC", "->", "getNumRegs", "(", ")", "<<", "\"]:\"", "<<", "(", "SrcSubReg", "?", "TRI", ".", "getSubRegIndexName", "(", "SrcSubReg", ")", ":", "\"\"", ")", "<<", "\" -> \"", "<<", "TRI", ".", "getRegClassName", "(", "DstRC", ")", "<<", "'['", "<<", "DstRC", "->", "getNumRegs", "(", ")", "<<", "\"]:\"", "<<", "(", "DstSubReg", "?", "TRI", ".", "getSubRegIndexName", "(", "DstSubReg", ")", ":", "\"\"", ")", "<<", "' '", "<<", "TRI", ".", "getRegClassName", "(", "NewRC", ")", "<<", "'['", "<<", "NewRC", "->", "getNumRegs", "(", ")", "<<", "\"]\\n\"", ")", ";", "return", "std", "::", "min", "(", "SrcRC", "->", "getNumRegs", "(", ")", ",", "DstRC", "->", "getNumRegs", "(", ")", ")", "<=", "NewRC", "->", "getNumRegs", "(", ")", ";", "}", "</s>" ]

[ "Subtarget", "Hooks", "." ]

[ "Z80", "Z80", "\"]:\"", "\"\"", "\" -> \"", "\"]:\"", "\"\"", "\"]\\n\"" ]

[]

[ "<s>", "static", "void", "pa_select_section", "(", "tree", "exp", ",", "int", "reloc", ",", "unsigned", "HOST_WIDE_INT", "align", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "VAR_DECL", "&&", "TREE_READONLY", "(", "exp", ")", "&&", "!", "TREE_THIS_VOLATILE", "(", "exp", ")", "&&", "DECL_INITIAL", "(", "exp", ")", "&&", "(", "DECL_INITIAL", "(", "exp", ")", "==", "error_mark_node", "||", "TREE_CONSTANT", "(", "DECL_INITIAL", "(", "exp", ")", ")", ")", "&&", "!", "reloc", ")", "{", "if", "(", "TARGET_SOM", "&&", "DECL_ONE_ONLY", "(", "exp", ")", "&&", "!", "DECL_WEAK", "(", "exp", ")", ")", "som_one_only_readonly_data_section", "(", ")", ";", "else", "readonly_data_section", "(", ")", ";", "}", "else", "if", "(", "CONSTANT_CLASS_P", "(", "exp", ")", "&&", "!", "reloc", ")", "readonly_data_section", "(", ")", ";", "else", "if", "(", "TARGET_SOM", "&&", "TREE_CODE", "(", "exp", ")", "==", "VAR_DECL", "&&", "DECL_ONE_ONLY", "(", "exp", ")", "&&", "!", "DECL_WEAK", "(", "exp", ")", ")", "som_one_only_data_section", "(", ")", ";", "else", "data_section", "(", ")", ";", "}", "</s>" ]

[ "On", "hpux10", ",", "the", "linker", "will", "give", "an", "error", "if", "we", "have", "a", "reference", "in", "the", "read-only", "data", "section", "to", "a", "symbol", "defined", "in", "a", "shared", "library", ".", "Therefore", ",", "expressions", "that", "might", "require", "a", "reloc", "can", "not", "be", "placed", "in", "the", "read-only", "data", "section", "." ]

[ "pa" ]

[]

[ "<s>", "static", "int", "ix86_mode_entry", "(", "int", "entity", ")", "{", "switch", "(", "entity", ")", "{", "case", "AVX_U128", ":", "return", "ix86_avx_u128_mode_entry", "(", ")", ";", "case", "I387_TRUNC", ":", "case", "I387_FLOOR", ":", "case", "I387_CEIL", ":", "case", "I387_MASK_PM", ":", "return", "I387_CW_ANY", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "a", "mode", "that", "ENTITY", "is", "assumed", "to", "be", "switched", "to", "at", "function", "entry", "." ]

[ "i386" ]

[]

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

[ "Output", "a", "reference", "from", "a", "function", "exception", "table", "to", "the", "type_info", "object", "X", ".", "Output", "these", "via", "a", "special", "assembly", "directive", "." ]

[ "c6x", "\"\\t.ehtype\\t\"", "\"\\t.word\\t\"" ]

[]

[ "<s>", "bool", "WebAssemblyCFGStackify", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** CFG Stackifying **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "const", "auto", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "EliminateMultipleEntryLoops", "(", "MF", ",", "MLI", ")", ";", "SortBlocks", "(", "MF", ",", "MLI", ")", ";", "PlaceMarkers", "(", "MF", ",", "MLI", ",", "TII", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** CFG Stackifying **********\\n\"", "\"********** Function: \"", "WebAssembly" ]

[]

[ "<s>", "unsigned", "NVPTXRegisterInfo", "::", "getRARegister", "(", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

[ "This", "method", "should", "return", "the", "register", "where", "the", "return", "address", "can", "be", "found", "." ]

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

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isPairableLdStInst", "(", "const", "MachineInstr", "&", "MI", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "AArch64", "::", "STRSui", ":", "case", "AArch64", "::", "STRDui", ":", "case", "AArch64", "::", "STRQui", ":", "case", "AArch64", "::", "STRXui", ":", "case", "AArch64", "::", "STRWui", ":", "case", "AArch64", "::", "LDRSui", ":", "case", "AArch64", "::", "LDRDui", ":", "case", "AArch64", "::", "LDRQui", ":", "case", "AArch64", "::", "LDRXui", ":", "case", "AArch64", "::", "LDRWui", ":", "case", "AArch64", "::", "LDRSWui", ":", "case", "AArch64", "::", "STURSi", ":", "case", "AArch64", "::", "STRSpre", ":", "case", "AArch64", "::", "STURDi", ":", "case", "AArch64", "::", "STRDpre", ":", "case", "AArch64", "::", "STURQi", ":", "case", "AArch64", "::", "STRQpre", ":", "case", "AArch64", "::", "STURWi", ":", "case", "AArch64", "::", "STRWpre", ":", "case", "AArch64", "::", "STURXi", ":", "case", "AArch64", "::", "STRXpre", ":", "case", "AArch64", "::", "LDURSi", ":", "case", "AArch64", "::", "LDRSpre", ":", "case", "AArch64", "::", "LDURDi", ":", "case", "AArch64", "::", "LDRDpre", ":", "case", "AArch64", "::", "LDURQi", ":", "case", "AArch64", "::", "LDRQpre", ":", "case", "AArch64", "::", "LDURWi", ":", "case", "AArch64", "::", "LDRWpre", ":", "case", "AArch64", "::", "LDURXi", ":", "case", "AArch64", "::", "LDRXpre", ":", "case", "AArch64", "::", "LDURSWi", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "pairing", "the", "given", "load", "or", "store", "may", "be", "paired", "with", "another", "." ]

[ "AArch64", "AArch64", "AArch64::STRSui", "AArch64::STRDui", "AArch64::STRQui", "AArch64::STRXui", "AArch64::STRWui", "AArch64::LDRSui", "AArch64::LDRDui", "AArch64::LDRQui", "AArch64::LDRXui", "AArch64::LDRWui", "AArch64::LDRSWui", "AArch64::STURSi", "AArch64::STRSpre", "AArch64::STURDi", "AArch64::STRDpre", "AArch64::STURQi", "AArch64::STRQpre", "AArch64::STURWi", "AArch64::STRWpre", "AArch64::STURXi", "AArch64::STRXpre", "AArch64::LDURSi", "AArch64::LDRSpre", "AArch64::LDURDi", "AArch64::LDRDpre", "AArch64::LDURQi", "AArch64::LDRQpre", "AArch64::LDURWi", "AArch64::LDRWpre", "AArch64::LDURXi", "AArch64::LDRXpre", "AArch64::LDURSWi" ]

[]

[ "<s>", "static", "unsigned", "s390_loop_unroll_adjust", "(", "unsigned", "nunroll", ",", "struct", "loop", "*", "loop", ")", "{", "basic_block", "*", "bbs", ";", "rtx_insn", "*", "insn", ";", "unsigned", "i", ";", "unsigned", "mem_count", "=", "0", ";", "if", "(", "s390_tune", "<", "PROCESSOR_2097_Z10", ")", "return", "nunroll", ";", "if", "(", "unroll_only_small_loops", ")", "{", "const", "unsigned", "int", "small_threshold", "=", "12", ";", "if", "(", "loop", "->", "ninsns", ">", "small_threshold", ")", "return", "0", ";", "const", "unsigned", "int", "max_insns", "=", "optimize", ">=", "3", "?", "36", ":", "24", ";", "nunroll", "=", "MIN", "(", "nunroll", ",", "max_insns", "/", "loop", "->", "ninsns", ")", ";", "}", "bbs", "=", "get_loop_body", "(", "loop", ")", ";", "subrtx_iterator", "::", "array_type", "array", ";", "for", "(", "i", "=", "0", ";", "i", "<", "loop", "->", "num_nodes", ";", "i", "++", ")", "FOR_BB_INSNS", "(", "bbs", "[", "i", "]", ",", "insn", ")", "if", "(", "INSN_P", "(", "insn", ")", "&&", "INSN_CODE", "(", "insn", ")", "!=", "-", "1", ")", "{", "rtx", "set", ";", "if", "(", "s390_tune", ">=", "PROCESSOR_2964_Z13", "&&", "loop", "->", "ninsns", "<=", "BLOCK_MEM_OPS_LOOP_INSNS", "&&", "(", "(", "set", "=", "single_set", "(", "insn", ")", ")", "!=", "NULL_RTX", ")", "&&", "(", "(", "GET_MODE", "(", "SET_DEST", "(", "set", ")", ")", "==", "BLKmode", "&&", "(", "GET_MODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "BLKmode", "||", "SET_SRC", "(", "set", ")", "==", "const0_rtx", ")", ")", "||", "(", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "COMPARE", "&&", "GET_MODE", "(", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "0", ")", ")", "==", "BLKmode", "&&", "GET_MODE", "(", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", ")", "==", "BLKmode", ")", ")", ")", "{", "free", "(", "bbs", ")", ";", "return", "1", ";", "}", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "insn", ")", ",", "NONCONST", ")", "if", "(", "MEM_P", "(", "*", "iter", ")", ")", "mem_count", "+=", "1", ";", "}", "free", "(", "bbs", ")", ";", "if", "(", "mem_count", "==", "0", ")", "return", "nunroll", ";", "switch", "(", "loop_depth", "(", "loop", ")", ")", "{", "case", "1", ":", "return", "MIN", "(", "nunroll", ",", "28", "/", "mem_count", ")", ";", "case", "2", ":", "return", "MIN", "(", "nunroll", ",", "22", "/", "mem_count", ")", ";", "default", ":", "return", "MIN", "(", "nunroll", ",", "16", "/", "mem_count", ")", ";", "}", "}", "</s>" ]

[ "This", "target", "hook", "implementation", "for", "TARGET_LOOP_UNROLL_ADJUST", "calculates", "a", "new", "number", "struct", "loop", "*", "loop", "should", "be", "unrolled", "if", "tuned", "for", "cpus", "with", "a", "built-in", "stride", "prefetcher", ".", "The", "loop", "is", "analyzed", "for", "memory", "accesses", "by", "calling", "check_dpu", "for", "each", "rtx", "of", "the", "loop", ".", "Depending", "on", "the", "loop_depth", "and", "the", "amount", "of", "memory", "accesses", "a", "new", "number", "<", "=nunroll", "is", "returned", "to", "improve", "the", "behaviour", "of", "the", "hardware", "prefetch", "unit", "." ]

[ "s390", "0", "12", "0", "3", "36", "24", "0", "1", "0", "1", "1", "1", "0", "1", "28", "2", "22", "16" ]

[]

[ "<s>", "static", "rtx", "gen_safe_HIGH64", "(", "rtx", "dest", ",", "HOST_WIDE_INT", "val", ")", "{", "return", "gen_rtx_SET", "(", "dest", ",", "GEN_INT", "(", "val", "&", "~", "(", "HOST_WIDE_INT", ")", "0x3ff", ")", ")", ";", "}", "</s>" ]

[ "The", "optimizer", "is", "not", "to", "assume", "anything", "about", "exactly", "which", "bits", "are", "set", "for", "a", "HIGH", ",", "they", "are", "unspecified", ".", "Unfortunately", "this", "leads", "to", "many", "missed", "optimizations", "during", "CSE", ".", "We", "mask", "out", "the", "non-HIGH", "bits", ",", "and", "matches", "a", "plain", "movdi", ",", "to", "alleviate", "this", "problem", "." ]

[ "sparc", "0x3ff" ]

[]

[ "<s>", "void", "HexagonRegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Hexagon", "::", "ADJCALLSTACKDOWN", ")", "{", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Hexagon", "::", "ADJCALLSTACKUP", ")", "{", "}", "else", "{", "assert", "(", "0", "&&", "\"Cannot handle this call frame pseudo instruction\"", ")", ";", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::ADJCALLSTACKDOWN", "Hexagon::ADJCALLSTACKUP", "0", "\"Cannot handle this call frame pseudo instruction\"" ]

[]

[ "<s>", "void", "J2FrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "SavedRegs", ".", "set", "(", "J2", "::", "R14", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "AMDGPUTargetLowering", "::", "AnalyzeReturn", "(", "CCState", "&", "State", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ")", "const", "{", "State", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_SI", ")", ";", "}", "</s>" ]

[ "AnalyzeReturn", "-", "Analyze", "the", "returned", "values", "of", "a", "return", ",", "incorporating", "info", "about", "the", "result", "values", "into", "this", "state", "." ]

[ "AMDGPU", "AMDGPU", "ISD::OutputArg", "SI" ]

[]

[ "<s>", "bool", "PadShortFunc", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "optForSize", "(", ")", ")", "return", "false", ";", "if", "(", "!", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "padShortFunctions", "(", ")", ")", "return", "false", ";", "TSM", ".", "init", "(", "&", "MF", ".", "getSubtarget", "(", ")", ")", ";", "ReturnBBs", ".", "clear", "(", ")", ";", "VisitedBBs", ".", "clear", "(", ")", ";", "findReturns", "(", "&", "MF", ".", "front", "(", ")", ")", ";", "bool", "MadeChange", "=", "false", ";", "MachineBasicBlock", "*", "MBB", ";", "unsigned", "int", "Cycles", "=", "0", ";", "for", "(", "DenseMap", "<", "MachineBasicBlock", "*", ",", "unsigned", "int", ">", "::", "iterator", "I", "=", "ReturnBBs", ".", "begin", "(", ")", ";", "I", "!=", "ReturnBBs", ".", "end", "(", ")", ";", "++", "I", ")", "{", "MBB", "=", "I", "->", "first", ";", "Cycles", "=", "I", "->", "second", ";", "if", "(", "Cycles", "<", "Threshold", ")", "{", "assert", "(", "MBB", "->", "size", "(", ")", ">", "0", "&&", "\"Basic block should contain at least a RET but is empty\"", ")", ";", "MachineBasicBlock", "::", "iterator", "ReturnLoc", "=", "--", "MBB", "->", "end", "(", ")", ";", "while", "(", "ReturnLoc", "->", "isDebugValue", "(", ")", ")", "--", "ReturnLoc", ";", "assert", "(", "ReturnLoc", "->", "isReturn", "(", ")", "&&", "!", "ReturnLoc", "->", "isCall", "(", ")", "&&", "\"Basic block does not end with RET\"", ")", ";", "addPadding", "(", "MBB", ",", "ReturnLoc", ",", "Threshold", "-", "Cycles", ")", ";", "NumBBsPadded", "++", ";", "MadeChange", "=", "true", ";", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "0", "\"Basic block should contain at least a RET but is empty\"", "\"Basic block does not end with RET\"" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "&", "SrcReg", ",", "Register", "&", "SrcReg2", ",", "int64_t", "&", "CmpMask", ",", "int64_t", "&", "CmpValue", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "CMP64ri32", ":", "case", "X86", "::", "CMP64ri8", ":", "case", "X86", "::", "CMP32ri", ":", "case", "X86", "::", "CMP32ri8", ":", "case", "X86", "::", "CMP16ri", ":", "case", "X86", "::", "CMP16ri8", ":", "case", "X86", "::", "CMP8ri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", ")", "{", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "}", "else", "{", "CmpMask", "=", "CmpValue", "=", "0", ";", "}", "return", "true", ";", "case", "X86", "::", "SUB64rm", ":", "case", "X86", "::", "SUB32rm", ":", "case", "X86", "::", "SUB16rm", ":", "case", "X86", "::", "SUB8rm", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "X86", "::", "SUB64rr", ":", "case", "X86", "::", "SUB32rr", ":", "case", "X86", "::", "SUB16rr", ":", "case", "X86", "::", "SUB8rr", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "X86", "::", "SUB64ri32", ":", "case", "X86", "::", "SUB64ri8", ":", "case", "X86", "::", "SUB32ri", ":", "case", "X86", "::", "SUB32ri8", ":", "case", "X86", "::", "SUB16ri", ":", "case", "X86", "::", "SUB16ri8", ":", "case", "X86", "::", "SUB8ri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "if", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "{", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "}", "else", "{", "CmpMask", "=", "CmpValue", "=", "0", ";", "}", "return", "true", ";", "case", "X86", "::", "CMP64rr", ":", "case", "X86", "::", "CMP32rr", ":", "case", "X86", "::", "CMP16rr", ":", "case", "X86", "::", "CMP8rr", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "X86", "::", "TEST8rr", ":", "case", "X86", "::", "TEST16rr", ":", "case", "X86", "::", "TEST32rr", ":", "case", "X86", "::", "TEST64rr", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "!=", "SrcReg", ")", "return", "false", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeCompare", "-", "For", "a", "comparison", "instruction", ",", "return", "the", "source", "registers", "in", "SrcReg", "and", "SrcReg2", "if", "having", "two", "register", "operands", ",", "and", "the", "value", "it", "compares", "against", "in", "CmpValue", "." ]

[ "X86", "X86", "X86::CMP64ri32", "X86::CMP64ri8", "X86::CMP32ri", "X86::CMP32ri8", "X86::CMP16ri", "X86::CMP16ri8", "X86::CMP8ri", "0", "0", "1", "0", "1", "0", "X86::SUB64rm", "X86::SUB32rm", "X86::SUB16rm", "X86::SUB8rm", "1", "0", "0", "0", "X86::SUB64rr", "X86::SUB32rr", "X86::SUB16rr", "X86::SUB8rr", "1", "2", "0", "0", "X86::SUB64ri32", "X86::SUB64ri8", "X86::SUB32ri", "X86::SUB32ri8", "X86::SUB16ri", "X86::SUB16ri8", "X86::SUB8ri", "1", "0", "2", "0", "2", "0", "X86::CMP64rr", "X86::CMP32rr", "X86::CMP16rr", "X86::CMP8rr", "0", "1", "0", "0", "X86::TEST8rr", "X86::TEST16rr", "X86::TEST32rr", "X86::TEST64rr", "0", "1", "0", "0", "0" ]

[]

[ "<s>", "void", "TOYInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "BuildMI", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "get", "(", "TOY", "::", "MOVrr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "TOY::MOVrr" ]

[]

[ "<s>", "static", "bool", "aarch64_vector_data_mode_p", "(", "machine_mode", "mode", ")", "{", "return", "aarch64_classify_vector_mode", "(", "mode", ")", "&", "VEC_ANY_DATA", ";", "}", "</s>" ]

[ "Return", "true", "if", "MODE", "is", "any", "of", "the", "data", "vector", "modes", ",", "including", "structure", "modes", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "RISCVPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "addPass", "(", "createRISCVGatherScatterLoweringPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "rtx", "ix86_find_base_term", "(", "rtx", "x", ")", "{", "rtx", "term", ";", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "!=", "CONST", ")", "return", "x", ";", "term", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "term", ")", "==", "PLUS", "&&", "(", "CONST_INT_P", "(", "XEXP", "(", "term", ",", "1", ")", ")", "||", "GET_CODE", "(", "XEXP", "(", "term", ",", "1", ")", ")", "==", "CONST_DOUBLE", ")", ")", "term", "=", "XEXP", "(", "term", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "term", ")", "!=", "UNSPEC", "||", "(", "XINT", "(", "term", ",", "1", ")", "!=", "UNSPEC_GOTPCREL", "&&", "XINT", "(", "term", ",", "1", ")", "!=", "UNSPEC_PCREL", ")", ")", "return", "x", ";", "return", "XVECEXP", "(", "term", ",", "0", ",", "0", ")", ";", "}", "return", "ix86_delegitimize_address", "(", "x", ")", ";", "}", "</s>" ]

[ "If", "X", "is", "a", "machine", "specific", "address", "(", "i.e", ".", "a", "symbol", "or", "label", "being", "referenced", "as", "a", "displacement", "from", "the", "GOT", "implemented", "using", "an", "UNSPEC", ")", ",", "then", "return", "the", "base", "term", ".", "Otherwise", "return", "X", "." ]

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

[]

[ "<s>", "int", "aarch_crypto_can_dual_issue", "(", "rtx_insn", "*", "producer_insn", ",", "rtx_insn", "*", "consumer_insn", ")", "{", "rtx", "producer_set", ",", "consumer_set", ";", "rtx", "producer_src", ",", "consumer_src", ";", "producer_set", "=", "single_set", "(", "producer_insn", ")", ";", "consumer_set", "=", "single_set", "(", "consumer_insn", ")", ";", "producer_src", "=", "producer_set", "?", "SET_SRC", "(", "producer_set", ")", ":", "NULL", ";", "consumer_src", "=", "consumer_set", "?", "SET_SRC", "(", "consumer_set", ")", ":", "NULL", ";", "if", "(", "producer_src", "&&", "consumer_src", "&&", "GET_CODE", "(", "producer_src", ")", "==", "UNSPEC", "&&", "GET_CODE", "(", "consumer_src", ")", "==", "UNSPEC", "&&", "(", "(", "XINT", "(", "producer_src", ",", "1", ")", "==", "UNSPEC_AESE", "&&", "XINT", "(", "consumer_src", ",", "1", ")", "==", "UNSPEC_AESMC", ")", "||", "(", "XINT", "(", "producer_src", ",", "1", ")", "==", "UNSPEC_AESD", "&&", "XINT", "(", "consumer_src", ",", "1", ")", "==", "UNSPEC_AESIMC", ")", ")", ")", "{", "unsigned", "int", "regno", "=", "REGNO", "(", "SET_DEST", "(", "producer_set", ")", ")", ";", "return", "REGNO", "(", "SET_DEST", "(", "consumer_set", ")", ")", "==", "regno", "&&", "REGNO", "(", "XVECEXP", "(", "consumer_src", ",", "0", ",", "0", ")", ")", "==", "regno", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "In", "ARMv8-A", "there", "'s", "a", "general", "expectation", "that", "AESE/AESMC", "and", "AESD/AESIMC", "sequences", "of", "the", "form", ":", "AESE", "Vn", ",", "_", "AESMC", "Vn", ",", "Vn", "will", "issue", "both", "instructions", "in", "a", "single", "cycle", "on", "super-scalar", "implementations", ".", "This", "function", "identifies", "such", "pairs", "." ]

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

[]

[ "<s>", "bool", "isAliased", "(", "const", "MachineFrameInfo", "*", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Test", "whether", "the", "memory", "pointed", "to", "by", "this", "PseudoSourceValue", "may", "also", "be", "pointed", "to", "by", "an", "LLVM", "IR", "Value", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "enum", "x86_64_reg_class", "merge_classes", "(", "enum", "x86_64_reg_class", "class1", ",", "enum", "x86_64_reg_class", "class2", ")", "{", "if", "(", "class1", "==", "class2", ")", "return", "class1", ";", "if", "(", "class1", "==", "X86_64_NO_CLASS", ")", "return", "class2", ";", "if", "(", "class2", "==", "X86_64_NO_CLASS", ")", "return", "class1", ";", "if", "(", "class1", "==", "X86_64_MEMORY_CLASS", "||", "class2", "==", "X86_64_MEMORY_CLASS", ")", "return", "X86_64_MEMORY_CLASS", ";", "if", "(", "(", "class1", "==", "X86_64_INTEGERSI_CLASS", "&&", "(", "class2", "==", "X86_64_SSESF_CLASS", "||", "class2", "==", "X86_64_SSEHF_CLASS", ")", ")", "||", "(", "class2", "==", "X86_64_INTEGERSI_CLASS", "&&", "(", "class1", "==", "X86_64_SSESF_CLASS", "||", "class1", "==", "X86_64_SSEHF_CLASS", ")", ")", ")", "return", "X86_64_INTEGERSI_CLASS", ";", "if", "(", "class1", "==", "X86_64_INTEGER_CLASS", "||", "class1", "==", "X86_64_INTEGERSI_CLASS", "||", "class2", "==", "X86_64_INTEGER_CLASS", "||", "class2", "==", "X86_64_INTEGERSI_CLASS", ")", "return", "X86_64_INTEGER_CLASS", ";", "if", "(", "class1", "==", "X86_64_X87_CLASS", "||", "class1", "==", "X86_64_X87UP_CLASS", "||", "class1", "==", "X86_64_COMPLEX_X87_CLASS", "||", "class2", "==", "X86_64_X87_CLASS", "||", "class2", "==", "X86_64_X87UP_CLASS", "||", "class2", "==", "X86_64_COMPLEX_X87_CLASS", ")", "return", "X86_64_MEMORY_CLASS", ";", "return", "X86_64_SSE_CLASS", ";", "}", "</s>" ]

[ "Return", "the", "union", "class", "of", "CLASS1", "and", "CLASS2", ".", "See", "the", "x86-64", "PS", "ABI", "for", "details", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "R600VectorRegMerger", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "*", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MRI", "=", "&", "(", "Fn", ".", "getRegInfo", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "MachineBasicBlock", "*", "MB", "=", "&", "*", "MBB", ";", "PreviousRegSeq", ".", "clear", "(", ")", ";", "PreviousRegSeqByReg", ".", "clear", "(", ")", ";", "PreviousRegSeqByUndefCount", ".", "clear", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MII", "=", "MB", "->", "begin", "(", ")", ",", "MIIE", "=", "MB", "->", "end", "(", ")", ";", "MII", "!=", "MIIE", ";", "++", "MII", ")", "{", "MachineInstr", "*", "MI", "=", "MII", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "REG_SEQUENCE", ")", "{", "if", "(", "TII", "->", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ".", "TSFlags", "&", "R600_InstFlag", "::", "TEX_INST", ")", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "for", "(", "MachineRegisterInfo", "::", "def_instr_iterator", "It", "=", "MRI", "->", "def_instr_begin", "(", "Reg", ")", ",", "E", "=", "MRI", "->", "def_instr_end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "RemoveMI", "(", "&", "(", "*", "It", ")", ")", ";", "}", "}", "continue", ";", "}", "RegSeqInfo", "RSI", "(", "*", "MRI", ",", "MI", ")", ";", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "areAllUsesSwizzeable", "(", "Reg", ")", ")", "continue", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying to optimize \"", ";", "MI", "->", "dump", "(", ")", ";", ")", ";", "RegSeqInfo", "CandidateRSI", ";", "std", "::", "vector", "<", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", ">", "RemapChan", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Using common slots...\\n\"", ";", ")", ";", "if", "(", "tryMergeUsingCommonSlot", "(", "RSI", ",", "CandidateRSI", ",", "RemapChan", ")", ")", "{", "RemoveMI", "(", "CandidateRSI", ".", "Instr", ")", ";", "MII", "=", "RebuildVector", "(", "&", "RSI", ",", "&", "CandidateRSI", ",", "RemapChan", ")", ";", "trackRSI", "(", "RSI", ")", ";", "continue", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Using free slots...\\n\"", ";", ")", ";", "RemapChan", ".", "clear", "(", ")", ";", "if", "(", "tryMergeUsingFreeSlot", "(", "RSI", ",", "CandidateRSI", ",", "RemapChan", ")", ")", "{", "RemoveMI", "(", "CandidateRSI", ".", "Instr", ")", ";", "MII", "=", "RebuildVector", "(", "&", "RSI", ",", "&", "CandidateRSI", ",", "RemapChan", ")", ";", "trackRSI", "(", "RSI", ")", ";", "continue", ";", "}", "trackRSI", "(", "RSI", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "R600", "AMDGPU::REG_SEQUENCE", "R600_InstFlag::TEX_INST", "1", "SI", "0", "\"Trying to optimize \"", "SI", "\"Using common slots...\\n\"", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "\"Using free slots...\\n\"", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "void", "OR1KInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "OR1K", "::", "GPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "OR1K", "::", "ORI", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "0", ")", ";", "else", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K", "OR1K::GPRRegClass", "OR1K::ORI", "0", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "const", "char", "*", "ashlsi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", "{", "int", "k", ";", "int", "*", "t", "=", "len", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "32", ")", "break", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "3", ",", "(", "\"clr %D0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"movw %A0,%C0\"", ")", ";", "*", "len", "=", "4", ";", "return", "(", "\"clr %D0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "case", "8", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "*", "len", "=", "4", ";", "if", "(", "reg0", ">=", "reg1", ")", "return", "(", "\"mov %D0,%C1\"", "CR_TAB", "\"mov %C0,%B1\"", "CR_TAB", "\"mov %B0,%A1\"", "CR_TAB", "\"clr %A0\"", ")", ";", "else", "return", "(", "\"clr %A0\"", "CR_TAB", "\"mov %B0,%A1\"", "CR_TAB", "\"mov %C0,%B1\"", "CR_TAB", "\"mov %D0,%C1\"", ")", ";", "}", "case", "16", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "reg0", "+", "2", "==", "reg1", ")", "return", "*", "len", "=", "2", ",", "(", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "3", ",", "(", "\"movw %C0,%A1\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "else", "return", "*", "len", "=", "4", ",", "(", "\"mov %C0,%A1\"", "CR_TAB", "\"mov %D0,%B1\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "}", "case", "24", ":", "*", "len", "=", "4", ";", "return", "(", "\"mov %D0,%A1\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "case", "31", ":", "*", "len", "=", "6", ";", "return", "(", "\"clr %D0\"", "CR_TAB", "\"lsr %A0\"", "CR_TAB", "\"ror %D0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "}", "len", "=", "t", ";", "}", "out_shift_with_cnt", "(", "\"lsl %A0\"", "CR_TAB", "\"rol %B0\"", "CR_TAB", "\"rol %C0\"", "CR_TAB", "\"rol %D0\"", ",", "insn", ",", "operands", ",", "len", ",", "4", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "32bit", "shift", "left", "(", "(", "long", ")", "x", "<", "<", "i", ")" ]

[ "avr", "2", "2", "2", "32", "3", "\"clr %D0\"", "\"clr %C0\"", "\"movw %A0,%C0\"", "4", "\"clr %D0\"", "\"clr %C0\"", "\"clr %B0\"", "\"clr %A0\"", "8", "0", "1", "4", "\"mov %D0,%C1\"", "\"mov %C0,%B1\"", "\"mov %B0,%A1\"", "\"clr %A0\"", "\"clr %A0\"", "\"mov %B0,%A1\"", "\"mov %C0,%B1\"", "\"mov %D0,%C1\"", "16", "0", "1", "2", "2", "\"clr %B0\"", "\"clr %A0\"", "3", "\"movw %C0,%A1\"", "\"clr %B0\"", "\"clr %A0\"", "4", "\"mov %C0,%A1\"", "\"mov %D0,%B1\"", "\"clr %B0\"", "\"clr %A0\"", "24", "4", "\"mov %D0,%A1\"", "\"clr %C0\"", "\"clr %B0\"", "\"clr %A0\"", "31", "6", "\"clr %D0\"", "\"lsr %A0\"", "\"ror %D0\"", "\"clr %C0\"", "\"clr %B0\"", "\"clr %A0\"", "\"lsl %A0\"", "\"rol %B0\"", "\"rol %C0\"", "\"rol %D0\"", "4", "\"\"" ]

[]

[ "<s>", "static", "int", "fr30_arg_partial_bytes", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "named", "==", "0", "||", "*", "cum", ">=", "FR30_NUM_ARG_REGS", ")", "return", "0", ";", "if", "(", "*", "cum", "+", "fr30_num_arg_regs", "(", "mode", ",", "type", ")", "<=", "FR30_NUM_ARG_REGS", ")", "return", "0", ";", "return", "(", "FR30_NUM_ARG_REGS", "-", "*", "cum", ")", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Returns", "the", "number", "of", "bytes", "in", "which", "*", "part", "*", "of", "a", "parameter", "of", "machine", "mode", "MODE", "and", "tree", "type", "TYPE", "(", "which", "may", "be", "NULL", "if", "the", "type", "is", "not", "known", ")", ".", "If", "the", "argument", "fits", "entirely", "in", "the", "argument", "registers", ",", "or", "entirely", "on", "the", "stack", ",", "then", "0", "is", "returned", ".", "CUM", "is", "the", "number", "of", "argument", "registers", "already", "used", "by", "earlier", "parameters", "to", "the", "function", "." ]

[ "fr30", "0", "0", "0" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "AVRFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "AVRInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "if", "(", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "fixStackStores", "(", "MBB", ",", "MI", ",", "TII", ",", "false", ")", ";", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "int", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "int", "Amount", "=", "TII", ".", "getFrameSize", "(", "*", "MI", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "assert", "(", "TFI", ".", "getStackAlignment", "(", ")", "==", "1", "&&", "\"Unsupported stack alignment\"", ")", ";", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "fixStackStores", "(", "MBB", ",", "MI", ",", "TII", ",", "true", ")", ";", "}", "else", "{", "assert", "(", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "unsigned", "addOpcode", ";", "if", "(", "isUInt", "<", "6", ">", "(", "Amount", ")", ")", "{", "addOpcode", "=", "AVR", "::", "ADIWRdK", ";", "}", "else", "{", "addOpcode", "=", "AVR", "::", "SUBIWRdK", ";", "Amount", "=", "-", "Amount", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPREAD", ")", ",", "AVR", "::", "R31R30", ")", ".", "addReg", "(", "AVR", "::", "SP", ")", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "addOpcode", ")", ",", "AVR", "::", "R31R30", ")", ".", "addReg", "(", "AVR", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Amount", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPWRITE", ")", ",", "AVR", "::", "SP", ")", ".", "addReg", "(", "AVR", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR", "AVR", "0", "1", "\"Unsupported stack alignment\"", "6", "AVR::ADIWRdK", "AVR::SUBIWRdK", "AVR::SPREAD", "AVR::R31R30", "AVR::SP", "AVR::R31R30", "AVR::R31R30", "3", "AVR::SPWRITE", "AVR::SP", "AVR::R31R30" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"CHERI range checker\"", ";", "}", "</s>" ]

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

[ "Mips", "\"CHERI range checker\"" ]

[]

[ "<s>", "T", "pop_front", "(", ")", "{", "T", "V", "=", "Queue", ".", "front", "(", ")", ";", "Queue", ".", "pop", "(", ")", ";", "Set", ".", "erase", "(", "V", ")", ";", "return", "V", ";", "}", "</s>" ]

[ "Remove", "the", "node", "at", "the", "front", ";", "never", "deletes", "." ]

[ "Hexagon" ]

[]

[ "<s>", "rtx", "cris_return_addr_rtx", "(", "int", "count", ",", "rtx", "frameaddr", "ATTRIBUTE_UNUSED", ")", "{", "cfun", "->", "machine", "->", "needs_return_address_on_stack", "=", "1", ";", "return", "count", "==", "0", "?", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "virtual_incoming_args_rtx", ",", "-", "4", ")", ")", ":", "NULL_RTX", ";", "}", "</s>" ]

[ "The", "RETURN_ADDR_RTX", "worker", ".", "We", "mark", "that", "the", "return", "address", "is", "used", ",", "either", "by", "EH", "or", "__builtin_return_address", ",", "for", "use", "by", "the", "function", "prologue", "and", "epilogue", ".", "FIXME", ":", "This", "is", "n't", "optimal", ";", "we", "just", "use", "the", "mark", "in", "the", "prologue", "and", "epilogue", "to", "say", "that", "the", "return", "address", "is", "to", "be", "stored", "in", "the", "stack", "frame", ".", "We", "could", "return", "SRP", "for", "leaf-functions", "and", "use", "the", "initial-value", "machinery", "." ]

[ "cris", "1", "0", "4" ]

[]

[ "<s>", "bool", "MSP430PassConfig", "::", "addInstSelector", "(", ")", "{", "PM", ".", "add", "(", "createMSP430ISelDag", "(", "getMSP430TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "R600SchedStrategy", "::", "releaseTopNode", "(", "SUnit", "*", "SU", ")", "{", "int", "IK", "=", "getInstKind", "(", "SU", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "IK", "<<", "\" <= \"", ")", ";", "DEBUG", "(", "SU", "->", "dump", "(", "DAG", ")", ")", ";", "Pending", "[", "IK", "]", "->", "push", "(", "SU", ")", ";", "}", "</s>" ]

[ "SU", "has", "had", "all", "predecessor", "dependencies", "resolved", "." ]

[ "R600", "\" <= \"" ]

[]

[ "<s>", "static", "bool", "nvptx_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "return", "regno", "==", "NVPTX_RETURN_REGNUM", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_VALUE_REGNO_P", "." ]

[ "nvptx" ]

[]

[ "<s>", "static", "bool", "ignore_vlmul_insn_p", "(", "rtx_insn", "*", "rinsn", ")", "{", "return", "get_attr_type", "(", "rinsn", ")", "==", "TYPE_VIMOVVX", "||", "get_attr_type", "(", "rinsn", ")", "==", "TYPE_VFMOVVF", "||", "get_attr_type", "(", "rinsn", ")", "==", "TYPE_VIMOVXV", "||", "get_attr_type", "(", "rinsn", ")", "==", "TYPE_VFMOVFV", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "ignores", "VLMUL", "field", "of", "VTYPE", "." ]

[ "riscv" ]

[]

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

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

[ "Hexagon" ]

[]

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

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

[ "TPC", "TPC", "TPC" ]

[]

[ "<s>", "static", "bool", "sh_lra_p", "(", "void", ")", "{", "return", "sh_lra_flag", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "use", "LRA", "instead", "of", "reload", "pass", "." ]

[ "sh" ]

[]

[ "<s>", "type_suffix_index", "function_resolver", "::", "infer_tuple_type", "(", "unsigned", "int", "argno", ")", "{", "return", "infer_vector_or_tuple_type", "(", "argno", ",", "vectors_per_tuple", "(", ")", ")", ";", "}", "</s>" ]

[ "If", "the", "function", "operates", "on", "tuples", "of", "vectors", ",", "require", "argument", "ARGNO", "to", "be", "a", "tuple", "with", "the", "appropriate", "number", "of", "vectors", ",", "otherwise", "require", "it", "to", "be", "a", "single", "vector", ".", "Return", "the", "associated", "type", "suffix", "on", "success", ",", "using", "TYPE_SUFFIX_b", "for", "predicates", ".", "Report", "an", "error", "and", "return", "NUM_TYPE_SUFFIXES", "on", "failure", "." ]

[ "aarch64" ]

[]

[ "<s>", "DecodeStatus", "HexagonDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "os", ",", "raw_ostream", "&", "cs", ")", "const", "{", "DecodeStatus", "Result", "=", "DecodeStatus", "::", "Success", ";", "bool", "Complete", "=", "false", ";", "Size", "=", "0", ";", "*", "CurrentBundle", "=", "&", "MI", ";", "MI", "=", "HexagonMCInstrInfo", "::", "createBundle", "(", ")", ";", "while", "(", "Result", "==", "Success", "&&", "Complete", "==", "false", ")", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "HEXAGON_INSTR_SIZE", ")", "return", "MCDisassembler", "::", "Fail", ";", "MCInst", "*", "Inst", "=", "new", "(", "getContext", "(", ")", ")", "MCInst", ";", "Result", "=", "getSingleInstruction", "(", "*", "Inst", ",", "MI", ",", "Bytes", ",", "Address", ",", "os", ",", "cs", ",", "Complete", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "Inst", ")", ")", ";", "Size", "+=", "HEXAGON_INSTR_SIZE", ";", "Bytes", "=", "Bytes", ".", "slice", "(", "HEXAGON_INSTR_SIZE", ")", ";", "}", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "Result", ";", "HexagonMCChecker", "Checker", "(", "*", "MCII", ",", "STI", ",", "MI", ",", "MI", ",", "*", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "if", "(", "!", "Checker", ".", "check", "(", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "return", "MCDisassembler", "::", "Success", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AArch64AsmBackend", "::", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "{", "return", "int64_t", "(", "Value", ")", "!=", "int64_t", "(", "int8_t", "(", "Value", ")", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "isStoreToStackSlotPostFE", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "unsigned", "Dummy", ";", "if", "(", "isFrameStoreOpcode", "(", "MI", ".", "getOpcode", "(", ")", ",", "Dummy", ")", ")", "{", "unsigned", "Reg", ";", "if", "(", "(", "Reg", "=", "isStoreToStackSlot", "(", "MI", ",", "FrameIndex", ")", ")", ")", "return", "Reg", ";", "SmallVector", "<", "const", "MachineMemOperand", "*", ",", "1", ">", "Accesses", ";", "if", "(", "hasStoreToStackSlot", "(", "MI", ",", "Accesses", ")", ")", "{", "FrameIndex", "=", "cast", "<", "FixedStackPseudoSourceValue", ">", "(", "Accesses", ".", "front", "(", ")", "->", "getPseudoValue", "(", ")", ")", "->", "getFrameIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "X86", "::", "AddrNumOperands", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

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

[ "X86", "X86", "1", "X86::AddrNumOperands", "0" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createMVEVPTOptimisationsPass", "(", ")", ")", ";", "addPass", "(", "createMLxExpansionPass", "(", ")", ")", ";", "if", "(", "EnableARMLoadStoreOpt", ")", "addPass", "(", "createARMLoadStoreOptimizationPass", "(", "true", ")", ")", ";", "if", "(", "!", "DisableA15SDOptimization", ")", "addPass", "(", "createA15SDOptimizerPass", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

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

[]

[ "<s>", "void", "s390_output_pool_entry", "(", "rtx", "exp", ",", "enum", "machine_mode", "mode", ",", "unsigned", "int", "align", ")", "{", "REAL_VALUE_TYPE", "r", ";", "switch", "(", "GET_MODE_CLASS", "(", "mode", ")", ")", "{", "case", "MODE_FLOAT", ":", "gcc_assert", "(", "GET_CODE", "(", "exp", ")", "==", "CONST_DOUBLE", ")", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "exp", ")", ";", "assemble_real", "(", "r", ",", "mode", ",", "align", ")", ";", "break", ";", "case", "MODE_INT", ":", "assemble_integer", "(", "exp", ",", "GET_MODE_SIZE", "(", "mode", ")", ",", "align", ",", "1", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Output", "the", "constant", "pool", "entry", "EXP", "in", "mode", "MODE", "with", "alignment", "ALIGN", "." ]

[ "s390", "1" ]

[]

[ "<s>", "bool", "isLegalMaskedStore", "(", "Type", "*", "DataTy", ")", "{", "return", "isLegalMaskedLoad", "(", "DataTy", ")", ";", "}", "</s>" ]

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

[ "ARM" ]

[]

[ "<s>", "void", "Mips16FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "ADJCALLSTACKDOWN", ")", "Amount", "=", "-", "Amount", ";", "const", "Mips16InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Mips16InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TII", ".", "adjustStackPtr", "(", "Mips", "::", "SP", ",", "Amount", ",", "MBB", ",", "I", ")", ";", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "Mips::ADJCALLSTACKDOWN", "Mips", "Mips", "Mips::SP" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "MF", ".", "getProperties", "(", ")", ".", "set", "(", "MachineFunctionProperties", "::", "Property", "::", "FailsVerification", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "R600Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "LLVM_DEBUG", "(", "MF", ".", "dump", "(", ")", ";", ")", ";", "OrderedBlks", ".", "clear", "(", ")", ";", "Visited", ".", "clear", "(", ")", ";", "FuncRep", "=", "&", "MF", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"LoopInfo:\\n\"", ";", "PrintLoopinfo", "(", "*", "MLI", ")", ";", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "LLVM_DEBUG", "(", "MDT", "->", "print", "(", "dbgs", "(", ")", ",", "(", "const", "Module", "*", ")", "nullptr", ")", ";", ")", ";", "PDT", "=", "&", "getAnalysis", "<", "MachinePostDominatorTree", ">", "(", ")", ";", "LLVM_DEBUG", "(", "PDT", "->", "print", "(", "dbgs", "(", ")", ")", ";", ")", ";", "prepare", "(", ")", ";", "run", "(", ")", ";", "LLVM_DEBUG", "(", "MF", ".", "dump", "(", ")", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "\"LoopInfo:\\n\"" ]

[]

[ "<s>", "void", "final_prescan_insn", "(", "rtx", "insn", ",", "rtx", "*", "operand", "ATTRIBUTE_UNUSED", ",", "int", "num_operands", "ATTRIBUTE_UNUSED", ")", "{", "static", "int", "last_insn_address", "=", "0", ";", "const", "int", "uid", "=", "INSN_UID", "(", "insn", ")", ";", "if", "(", "TARGET_ADDRESSES", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"; 0x%x %d\\n\"", ",", "INSN_ADDRESSES", "(", "uid", ")", ",", "INSN_ADDRESSES", "(", "uid", ")", "-", "last_insn_address", ")", ";", "last_insn_address", "=", "INSN_ADDRESSES", "(", "uid", ")", ";", "}", "}", "</s>" ]

[ "If", "defined", ",", "a", "C", "statement", "to", "be", "executed", "just", "prior", "to", "the", "output", "of", "assembler", "code", "for", "INSN", ",", "to", "modify", "the", "extracted", "operands", "so", "they", "will", "be", "output", "differently", ".", "Here", "the", "argument", "OPVEC", "is", "the", "vector", "containing", "the", "operands", "extracted", "from", "INSN", ",", "and", "NOPERANDS", "is", "the", "number", "of", "elements", "of", "the", "vector", "which", "contain", "meaningful", "data", "for", "this", "insn", ".", "The", "contents", "of", "this", "vector", "are", "what", "will", "be", "used", "to", "convert", "the", "insn", "template", "into", "assembler", "code", ",", "so", "you", "can", "change", "the", "assembler", "output", "by", "changing", "the", "contents", "of", "the", "vector", ".", "We", "use", "it", "to", "check", "if", "the", "current", "insn", "needs", "a", "nop", "in", "front", "of", "it", "because", "of", "load", "delays", ",", "and", "also", "to", "update", "the", "delay", "slot", "statistics", "." ]

[ "h8300", "0", "\"; 0x%x %d\\n\"" ]

[]

[ "<s>", "bool", "NVVMReflect", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "NVVMReflectEnabled", ")", "return", "false", ";", "setVarMap", "(", ")", ";", "ReflectFunction", "=", "M", ".", "getFunction", "(", "NVVM_REFLECT_FUNCTION", ")", ";", "if", "(", "!", "ReflectFunction", ")", "return", "false", ";", "assert", "(", "ReflectFunction", "->", "isDeclaration", "(", ")", "&&", "\"_reflect function should not have a body\"", ")", ";", "assert", "(", "ReflectFunction", "->", "getReturnType", "(", ")", "->", "isIntegerTy", "(", ")", "&&", "\"_reflect's return type should be integer\"", ")", ";", "std", "::", "vector", "<", "Instruction", "*", ">", "ToRemove", ";", "for", "(", "User", "*", "U", ":", "ReflectFunction", "->", "users", "(", ")", ")", "{", "assert", "(", "isa", "<", "CallInst", ">", "(", "U", ")", "&&", "\"Only a call instruction can use _reflect\"", ")", ";", "CallInst", "*", "Reflect", "=", "cast", "<", "CallInst", ">", "(", "U", ")", ";", "assert", "(", "(", "Reflect", "->", "getNumOperands", "(", ")", "==", "2", ")", "&&", "\"Only one operand expect for _reflect function\"", ")", ";", "const", "Value", "*", "conv", "=", "Reflect", "->", "getArgOperand", "(", "0", ")", ";", "assert", "(", "isa", "<", "CallInst", ">", "(", "conv", ")", "&&", "\"Expected a const-to-gen conversion\"", ")", ";", "const", "CallInst", "*", "ConvCall", "=", "cast", "<", "CallInst", ">", "(", "conv", ")", ";", "const", "Value", "*", "str", "=", "ConvCall", "->", "getArgOperand", "(", "0", ")", ";", "assert", "(", "isa", "<", "ConstantExpr", ">", "(", "str", ")", "&&", "\"Format of _reflect function not recognized\"", ")", ";", "const", "ConstantExpr", "*", "GEP", "=", "cast", "<", "ConstantExpr", ">", "(", "str", ")", ";", "const", "Value", "*", "Sym", "=", "GEP", "->", "getOperand", "(", "0", ")", ";", "assert", "(", "isa", "<", "Constant", ">", "(", "Sym", ")", "&&", "\"Format of _reflect function not recognized\"", ")", ";", "const", "Constant", "*", "SymStr", "=", "cast", "<", "Constant", ">", "(", "Sym", ")", ";", "assert", "(", "isa", "<", "ConstantDataSequential", ">", "(", "SymStr", "->", "getOperand", "(", "0", ")", ")", "&&", "\"Format of _reflect function not recognized\"", ")", ";", "assert", "(", "cast", "<", "ConstantDataSequential", ">", "(", "SymStr", "->", "getOperand", "(", "0", ")", ")", "->", "isCString", "(", ")", "&&", "\"Format of _reflect function not recognized\"", ")", ";", "std", "::", "string", "ReflectArg", "=", "cast", "<", "ConstantDataSequential", ">", "(", "SymStr", "->", "getOperand", "(", "0", ")", ")", "->", "getAsString", "(", ")", ";", "ReflectArg", "=", "ReflectArg", ".", "substr", "(", "0", ",", "ReflectArg", ".", "size", "(", ")", "-", "1", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Arg of _reflect : \"", "<<", "ReflectArg", "<<", "\"\\n\"", ")", ";", "int", "ReflectVal", "=", "0", ";", "if", "(", "VarMap", ".", "find", "(", "ReflectArg", ")", "!=", "VarMap", ".", "end", "(", ")", ")", "{", "ReflectVal", "=", "VarMap", "[", "ReflectArg", "]", ";", "}", "Reflect", "->", "replaceAllUsesWith", "(", "ConstantInt", "::", "get", "(", "Reflect", "->", "getType", "(", ")", ",", "ReflectVal", ")", ")", ";", "ToRemove", ".", "push_back", "(", "Reflect", ")", ";", "}", "if", "(", "ToRemove", ".", "size", "(", ")", "==", "0", ")", "return", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ToRemove", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "ToRemove", "[", "i", "]", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "NVPTX", "\"_reflect function should not have a body\"", "\"_reflect's return type should be integer\"", "\"Only a call instruction can use _reflect\"", "2", "\"Only one operand expect for _reflect function\"", "0", "\"Expected a const-to-gen conversion\"", "0", "\"Format of _reflect function not recognized\"", "0", "\"Format of _reflect function not recognized\"", "0", "\"Format of _reflect function not recognized\"", "0", "\"Format of _reflect function not recognized\"", "0", "0", "1", "\"Arg of _reflect : \"", "\"\\n\"", "0", "0", "0" ]

[]

[ "<s>", "bool", "BPFTargetLowering", "::", "isTruncateFree", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "if", "(", "!", "VT1", ".", "isInteger", "(", ")", "||", "!", "VT2", ".", "isInteger", "(", ")", ")", "return", "false", ";", "unsigned", "NumBits1", "=", "VT1", ".", "getSizeInBits", "(", ")", ";", "unsigned", "NumBits2", "=", "VT2", ".", "getSizeInBits", "(", ")", ";", "return", "NumBits1", ">", "NumBits2", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "free", "to", "truncate", "a", "value", "of", "type", "Ty1", "to", "type", "Ty2", "." ]

[ "BPF", "BPF" ]

[]

[ "<s>", "void", "Z80oldTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"ReplaceNodeResults: \"", ";", "N", "->", "dump", "(", "&", "DAG", ")", ")", ";", "}", "</s>" ]

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

[ "Z80old", "Z80old", "\"ReplaceNodeResults: \"" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "inlineStackProbe", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "PrologMBB", ")", "const", "{", "const", "StringRef", "ChkStkStubSymbol", "=", "\"__chkstk_stub\"", ";", "MachineInstr", "*", "ChkStkStub", "=", "nullptr", ";", "for", "(", "MachineInstr", "&", "MI", ":", "PrologMBB", ")", "{", "if", "(", "MI", ".", "isCall", "(", ")", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "isSymbol", "(", ")", "&&", "ChkStkStubSymbol", "==", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ")", "{", "ChkStkStub", "=", "&", "MI", ";", "break", ";", "}", "}", "if", "(", "ChkStkStub", "!=", "nullptr", ")", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "std", "::", "next", "(", "ChkStkStub", "->", "getIterator", "(", ")", ")", ";", "assert", "(", "std", "::", "prev", "(", "MBBI", ")", ".", "operator", "==", "(", "ChkStkStub", ")", "&&", "\"MBBI expected after __chkstk_stub.\"", ")", ";", "DebugLoc", "DL", "=", "PrologMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "emitStackProbeInline", "(", "MF", ",", "PrologMBB", ",", "MBBI", ",", "DL", ",", "true", ")", ";", "ChkStkStub", "->", "eraseFromParent", "(", ")", ";", "}", "}", "</s>" ]

[ "Replace", "a", "StackProbe", "inline-stub", "with", "the", "actual", "probe", "code", "inline", "." ]

[ "X86", "X86", "\"__chkstk_stub\"", "0", "0", "\"MBBI expected after __chkstk_stub.\"" ]

[]

[ "<s>", "virtual", "EVT", "getSetCCResultType", "(", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i1", ",", "VT", ".", "getVectorNumElements", "(", ")", ")", ";", "return", "MVT", "::", "i1", ";", "}", "</s>" ]

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

[ "NVPTX", "MVT::getVectorVT", "MVT::i1", "MVT::i1" ]

[]

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

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

[ "M68k", "M68k" ]

[]

[ "<s>", "bool", "AMDGPUPromoteAllocaToVector", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", "||", "DisablePromoteAllocaToVector", ")", "return", "false", ";", "const", "TargetMachine", "*", "TM", ";", "if", "(", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ")", "TM", "=", "&", "TPC", "->", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "else", "return", "false", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "AMDGPUSubtarget", "::", "get", "(", "*", "TM", ",", "F", ")", ";", "if", "(", "!", "ST", ".", "isPromoteAllocaEnabled", "(", ")", ")", "return", "false", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", "F", ")", ";", "MaxVGPRs", "=", "ST", ".", "getMaxNumVGPRs", "(", "ST", ".", "getWavesPerEU", "(", "F", ")", ".", "first", ")", ";", "}", "else", "{", "MaxVGPRs", "=", "128", ";", "}", "bool", "Changed", "=", "false", ";", "BasicBlock", "&", "EntryBB", "=", "*", "F", ".", "begin", "(", ")", ";", "SmallVector", "<", "AllocaInst", "*", ",", "16", ">", "Allocas", ";", "for", "(", "Instruction", "&", "I", ":", "EntryBB", ")", "{", "if", "(", "AllocaInst", "*", "AI", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "&", "I", ")", ")", "Allocas", ".", "push_back", "(", "AI", ")", ";", "}", "for", "(", "AllocaInst", "*", "AI", ":", "Allocas", ")", "{", "if", "(", "handleAlloca", "(", "*", "AI", ")", ")", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "128", "16" ]

[]

[ "<s>", "static", "void", "block_move_call", "(", "rtx", "dest_reg", ",", "rtx", "src_reg", ",", "rtx", "bytes_rtx", ")", "{", "if", "(", "GET_MODE", "(", "bytes_rtx", ")", "!=", "VOIDmode", "&&", "GET_MODE", "(", "bytes_rtx", ")", "!=", "Pmode", ")", "bytes_rtx", "=", "convert_to_mode", "(", "Pmode", ",", "bytes_rtx", ",", "1", ")", ";", "emit_library_call", "(", "m32r_function_symbol", "(", "\"memcpy\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "dest_reg", ",", "Pmode", ",", "src_reg", ",", "Pmode", ",", "convert_to_mode", "(", "TYPE_MODE", "(", "sizetype", ")", ",", "bytes_rtx", ",", "TYPE_UNSIGNED", "(", "sizetype", ")", ")", ",", "TYPE_MODE", "(", "sizetype", ")", ")", ";", "}", "</s>" ]

[ "Use", "a", "library", "function", "to", "move", "some", "bytes", "." ]

[ "m32r", "1", "\"memcpy\"" ]

[]

[ "<s>", "unsigned", "BlackfinRegisterInfo", "::", "getRARegister", "(", ")", "const", "{", "return", "BF", "::", "RETS", ";", "}", "</s>" ]

[ "This", "method", "should", "return", "the", "register", "where", "the", "return", "address", "can", "be", "found", "." ]

[ "Blackfin", "BF::RETS" ]

[]

[ "<s>", "virtual", "unsigned", "int", "execute", "(", "function", "*", ")", "{", "return", "rest_of_insert_bti", "(", ")", ";", "}", "</s>" ]

[ "Main", "entry", "point", "for", "this", "pass", "." ]

[ "aarch64" ]

[]

[ "<s>", "unsigned", "AMDGPURegisterBankInfo", "::", "copyCost", "(", "const", "RegisterBank", "&", "Dst", ",", "const", "RegisterBank", "&", "Src", ",", "unsigned", "Size", ")", "const", "{", "if", "(", "Dst", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SGPRRegBankID", "&&", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "VGPRRegBankID", ")", "return", "std", "::", "numeric_limits", "<", "unsigned", ">", "::", "max", "(", ")", ";", "if", "(", "Size", "==", "1", "&&", "Dst", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SCCRegBankID", "&&", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SGPRRegBankID", ")", "return", "std", "::", "numeric_limits", "<", "unsigned", ">", "::", "max", "(", ")", ";", "return", "RegisterBankInfo", "::", "copyCost", "(", "Dst", ",", "Src", ",", "Size", ")", ";", "}", "</s>" ]

[ "Get", "the", "cost", "of", "a", "copy", "from", "B", "to", "A", ",", "or", "put", "differently", ",", "get", "the", "cost", "of", "A", "=", "COPY", "B", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::SGPRRegBankID", "AMDGPU::VGPRRegBankID", "1", "AMDGPU::SCCRegBankID", "AMDGPU::SGPRRegBankID" ]

[]

[ "<s>", "enum", "reg_class", "mcore_secondary_reload_class", "(", "enum", "reg_class", "class", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "if", "(", "TEST_HARD_REG_BIT", "(", "reg_class_contents", "[", "class", "]", ",", "15", ")", "&&", "!", "mcore_r15_operand_p", "(", "x", ")", ")", "return", "LRW_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Implement", "SECONDARY_RELOAD_CLASS", ".", "If", "CLASS", "contains", "r15", ",", "and", "we", "ca", "n't", "directly", "move", "X", "into", "it", ",", "use", "r1-r14", "as", "a", "temporary", "." ]

[ "mcore", "15" ]

[]

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

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "ECLair" ]

[]

[ "<s>", "void", "M680x0InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "assert", "(", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectSize", "(", "FrameIndex", ")", "==", "4", "&&", "\"Stack slot too small for store\"", ")", ";", "unsigned", "Opc", "=", "getStoreRegOpcode", "(", "SrcReg", ",", "RC", ",", "TRI", ",", "Subtarget", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ")", ",", "FrameIndex", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "</s>" ]

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

[ "M680x0", "M680x0", "4", "\"Stack slot too small for store\"" ]

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "needsFrameBaseReg", "(", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "if", "(", "!", "MI", "->", "mayLoadOrStore", "(", ")", ")", "return", "false", ";", "int64_t", "FullOffset", "=", "Offset", "+", "getScratchInstrOffset", "(", "MI", ")", ";", "if", "(", "SIInstrInfo", "::", "isMUBUF", "(", "*", "MI", ")", ")", "return", "!", "SIInstrInfo", "::", "isLegalMUBUFImmOffset", "(", "FullOffset", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "return", "!", "TII", "->", "isLegalFLATOffset", "(", "FullOffset", ",", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ",", "true", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "function_builder", "::", "add_overloaded_function", "(", "const", "function_instance", "&", "instance", ",", "uint64_t", "required_extensions", ")", "{", "char", "*", "name", "=", "get_name", "(", "instance", ",", "true", ")", ";", "if", "(", "registered_function", "*", "*", "map_value", "=", "m_overload_names", ".", "get", "(", "name", ")", ")", "{", "gcc_assert", "(", "(", "*", "map_value", ")", "->", "instance", "==", "instance", "&&", "(", "(", "*", "map_value", ")", "->", "required_extensions", "&", "~", "required_extensions", ")", "==", "0", ")", ";", "obstack_free", "(", "&", "m_string_obstack", ",", "name", ")", ";", "}", "else", "{", "registered_function", "&", "rfn", "=", "add_function", "(", "instance", ",", "name", ",", "m_overload_type", ",", "NULL_TREE", ",", "required_extensions", ",", "true", ",", "m_direct_overloads", ")", ";", "m_overload_names", ".", "put", "(", "name", ",", "&", "rfn", ")", ";", "}", "}", "</s>" ]

[ "Add", "one", "function", "decl", "for", "INSTANCE", ",", "to", "be", "used", "with", "manual", "overload", "resolution", ".", "REQUIRED_EXTENSIONS", "are", "the", "set", "of", "architecture", "extensions", "that", "the", "function", "requires", ".", "For", "simplicity", ",", "deal", "with", "duplicate", "attempts", "to", "add", "the", "same", "function", ",", "including", "cases", "in", "which", "the", "new", "function", "requires", "more", "features", "than", "the", "original", "one", "did", ".", "In", "that", "case", "we", "'ll", "check", "whether", "the", "required", "features", "are", "available", "as", "part", "of", "resolving", "the", "function", "to", "the", "relevant", "unique", "function", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "unsigned", "HSAILInstrInfo", "::", "isLoadFromStackSlotPostFE", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "isLoadFromStackSlot", "(", "MI", ",", "FrameIndex", ")", ";", "}", "</s>" ]

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

[ "HSAIL", "HSAIL" ]

[]

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

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

[ "DLX", "\"DLX Assembly Printer\"" ]

[]

[ "<s>", "const", "TeakRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

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

[ "Teak", "Teak" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "AVRFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "AVRInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "if", "(", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "fixStackStores", "(", "MBB", ",", "MI", ",", "TII", ",", "false", ")", ";", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "int", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "int", "Amount", "=", "TII", ".", "getFrameSize", "(", "*", "MI", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "assert", "(", "getStackAlign", "(", ")", "==", "Align", "(", "1", ")", "&&", "\"Unsupported stack alignment\"", ")", ";", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "fixStackStores", "(", "MBB", ",", "MI", ",", "TII", ",", "true", ")", ";", "}", "else", "{", "assert", "(", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "unsigned", "addOpcode", ";", "if", "(", "isUInt", "<", "6", ">", "(", "Amount", ")", ")", "{", "addOpcode", "=", "AVR", "::", "ADIWRdK", ";", "}", "else", "{", "addOpcode", "=", "AVR", "::", "SUBIWRdK", ";", "Amount", "=", "-", "Amount", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPREAD", ")", ",", "AVR", "::", "R31R30", ")", ".", "addReg", "(", "AVR", "::", "SP", ")", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "addOpcode", ")", ",", "AVR", "::", "R31R30", ")", ".", "addReg", "(", "AVR", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Amount", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPWRITE", ")", ",", "AVR", "::", "SP", ")", ".", "addReg", "(", "AVR", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR", "AVR", "0", "1", "\"Unsupported stack alignment\"", "6", "AVR::ADIWRdK", "AVR::SUBIWRdK", "AVR::SPREAD", "AVR::R31R30", "AVR::SP", "AVR::R31R30", "AVR::R31R30", "3", "AVR::SPWRITE", "AVR::SP", "AVR::R31R30" ]

[]

[ "<s>", "static", "rtx", "emit_multi_reg_push", "(", "unsigned", "long", "mask", ")", "{", "int", "num_regs", "=", "0", ";", "int", "num_dwarf_regs", ";", "int", "i", ",", "j", ";", "rtx", "par", ";", "rtx", "dwarf", ";", "int", "dwarf_par_index", ";", "rtx", "tmp", ",", "reg", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "LAST_ARM_REGNUM", ";", "i", "++", ")", "if", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "num_regs", "++", ";", "gcc_assert", "(", "num_regs", "&&", "num_regs", "<=", "16", ")", ";", "num_dwarf_regs", "=", "num_regs", ";", "if", "(", "mask", "&", "(", "1", "<<", "PC_REGNUM", ")", ")", "num_dwarf_regs", "--", ";", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_regs", ")", ")", ";", "dwarf", "=", "gen_rtx_SEQUENCE", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_dwarf_regs", "+", "1", ")", ")", ";", "dwarf_par_index", "=", "1", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "LAST_ARM_REGNUM", ";", "i", "++", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_frame_mem", "(", "BLKmode", ",", "gen_rtx_PRE_DEC", "(", "BLKmode", ",", "stack_pointer_rtx", ")", ")", ",", "gen_rtx_UNSPEC", "(", "BLKmode", ",", "gen_rtvec", "(", "1", ",", "reg", ")", ",", "UNSPEC_PUSH_MULT", ")", ")", ";", "if", "(", "i", "!=", "PC_REGNUM", ")", "{", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_frame_mem", "(", "SImode", ",", "stack_pointer_rtx", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "dwarf_par_index", ")", "=", "tmp", ";", "dwarf_par_index", "++", ";", "}", "break", ";", "}", "}", "for", "(", "j", "=", "1", ",", "i", "++", ";", "j", "<", "num_regs", ";", "i", "++", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "j", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "reg", ")", ";", "if", "(", "i", "!=", "PC_REGNUM", ")", "{", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "stack_pointer_rtx", ",", "4", "*", "j", ")", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "dwarf_par_index", "++", ")", "=", "tmp", ";", "}", "j", "++", ";", "}", "}", "par", "=", "emit_insn", "(", "par", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "SImode", ",", "stack_pointer_rtx", ",", "gen_rtx_PLUS", "(", "SImode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "4", "*", "num_regs", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "0", ")", "=", "tmp", ";", "REG_NOTES", "(", "par", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_FRAME_RELATED_EXPR", ",", "dwarf", ",", "REG_NOTES", "(", "par", ")", ")", ";", "return", "par", ";", "}", "</s>" ]

[ "Generate", "and", "emit", "an", "insn", "that", "we", "will", "recognize", "as", "a", "push_multi", ".", "Unfortunately", ",", "since", "this", "insn", "does", "not", "reflect", "very", "well", "the", "actual", "semantics", "of", "the", "operation", ",", "we", "need", "to", "annotate", "the", "insn", "for", "the", "benefit", "of", "DWARF2", "frame", "unwind", "information", "." ]

[ "arm", "0", "0", "1", "16", "1", "1", "1", "0", "1", "0", "0", "1", "1", "0", "1", "1", "0", "4", "1", "0", "4", "1", "0", "0" ]

[]