Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "HexagonTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "return", "{", "0u", ",", "nullptr", "}", ";", "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "f32", ":", "return", "{", "0u", ",", "&", "Hexagon", "::", "IntRegsRegClass", "}", ";", "case", "MVT", "::", "i64", ":", "case", "MVT", "::", "f64", ":", "return", "{", "0u", ",", "&", "Hexagon", "::", "DoubleRegsRegClass", "}", ";", "}", "break", ";", "case", "'a'", ":", "if", "(", "VT", "!=", "MVT", "::", "i32", ")", "return", "{", "0u", ",", "nullptr", "}", ";", "return", "{", "0u", ",", "&", "Hexagon", "::", "ModRegsRegClass", "}", ";", "case", "'q'", ":", "switch", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "default", ":", "return", "{", "0u", ",", "nullptr", "}", ";", "case", "512", ":", "case", "1024", ":", "return", "{", "0u", ",", "&", "Hexagon", "::", "HvxQRRegClass", "}", ";", "}", "break", ";", "case", "'v'", ":", "switch", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "default", ":", "return", "{", "0u", ",", "nullptr", "}", ";", "case", "512", ":", "return", "{", "0u", ",", "&", "Hexagon", "::", "HvxVRRegClass", "}", ";", "case", "1024", ":", "if", "(", "Subtarget", ".", "hasV60TOps", "(", ")", "&&", "Subtarget", ".", "useHVX128BOps", "(", ")", ")", "return", "{", "0u", ",", "&", "Hexagon", "::", "HvxVRRegClass", "}", ";", "return", "{", "0u", ",", "&", "Hexagon", "::", "HvxWRRegClass", "}", ";", "case", "2048", ":", "return", "{", "0u", ",", "&", "Hexagon", "::", "HvxWRRegClass", "}", ";", "}", "break", ";", "default", ":", "return", "{", "0u", ",", "nullptr", "}", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "1", "0", "0u", "MVT::i1", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::f32", "0u", "Hexagon::IntRegsRegClass", "MVT::i64", "MVT::f64", "0u", "Hexagon::DoubleRegsRegClass", "MVT::i32", "0u", "0u", "Hexagon::ModRegsRegClass", "0u", "512", "1024", "0u", "Hexagon::HvxQRRegClass", "0u", "512", "0u", "Hexagon::HvxVRRegClass", "1024", "0u", "Hexagon::HvxVRRegClass", "0u", "Hexagon::HvxWRRegClass", "2048", "0u", "Hexagon::HvxWRRegClass", "0u" ]

[]

[ "<s>", "static", "void", "arm_function_arg_advance", "(", "cumulative_args_t", "pcum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "pcum", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "if", "(", "pcum", "->", "pcs_variant", "<=", "ARM_PCS_AAPCS_LOCAL", ")", "{", "aapcs_layout_arg", "(", "pcum", ",", "mode", ",", "type", ",", "named", ")", ";", "if", "(", "pcum", "->", "aapcs_cprc_slot", ">=", "0", ")", "{", "aapcs_cp_arg_layout", "[", "pcum", "->", "aapcs_cprc_slot", "]", ".", "advance", "(", "pcum", ",", "mode", ",", "type", ")", ";", "pcum", "->", "aapcs_cprc_slot", "=", "-", "1", ";", "}", "pcum", "->", "aapcs_arg_processed", "=", "false", ";", "pcum", "->", "aapcs_ncrn", "=", "pcum", "->", "aapcs_next_ncrn", ";", "pcum", "->", "aapcs_reg", "=", "NULL_RTX", ";", "pcum", "->", "aapcs_partial", "=", "0", ";", "}", "else", "{", "pcum", "->", "nargs", "+=", "1", ";", "if", "(", "arm_vector_mode_supported_p", "(", "mode", ")", "&&", "pcum", "->", "named_count", ">", "pcum", "->", "nargs", "&&", "TARGET_IWMMXT_ABI", ")", "pcum", "->", "iwmmxt_nregs", "+=", "1", ";", "else", "pcum", "->", "nregs", "+=", "ARM_NUM_REGS2", "(", "mode", ",", "type", ")", ";", "}", "}", "</s>" ]

[ "Update", "the", "data", "in", "PCUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")" ]

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

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "k_Immediate", ":", "OS", "<<", "\"Imm<\"", ";", "Imm", ".", "Val", "->", "print", "(", "OS", ")", ";", "OS", "<<", "\">\"", ";", "break", ";", "case", "k_Memory", ":", "OS", "<<", "\"Mem<\"", ";", "Mem", ".", "Base", "->", "print", "(", "OS", ")", ";", "OS", "<<", "\", \"", ";", "Mem", ".", "Off", "->", "print", "(", "OS", ")", ";", "OS", "<<", "\">\"", ";", "break", ";", "case", "k_PhysRegister", ":", "OS", "<<", "\"PhysReg<\"", "<<", "PhysReg", ".", "Num", "<<", "\">\"", ";", "break", ";", "case", "k_RegisterIndex", ":", "OS", "<<", "\"RegIdx<\"", "<<", "RegIdx", ".", "Index", "<<", "\":\"", "<<", "RegIdx", ".", "Kind", "<<", "\">\"", ";", "break", ";", "case", "k_Token", ":", "OS", "<<", "Tok", ".", "Data", ";", "break", ";", "}", "}", "</s>" ]

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

[ "Mips", "\"Imm<\"", "\">\"", "\"Mem<\"", "\", \"", "\">\"", "\"PhysReg<\"", "\">\"", "\"RegIdx<\"", "\":\"", "\">\"" ]

[]

[ "<s>", "bool", "Tile64TargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "Context", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_Tile64", ")", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "Tile64", "ISD::OutputArg", "16" ]

[]

[ "<s>", "bool", "SIInsertSkips", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "SkipThreshold", "=", "SkipThresholdFlag", ";", "bool", "HaveKill", "=", "false", ";", "bool", "MadeChange", "=", "false", ";", "SmallVector", "<", "MachineBasicBlock", "*", ",", "16", ">", "ExecBranchStack", ";", "MachineFunction", "::", "iterator", "NextBB", ";", "MachineBasicBlock", "*", "EmptyMBBAtEnd", "=", "nullptr", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "BI", "=", "NextBB", ")", "{", "NextBB", "=", "std", "::", "next", "(", "BI", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "bool", "HaveSkipBlock", "=", "false", ";", "if", "(", "!", "ExecBranchStack", ".", "empty", "(", ")", "&&", "ExecBranchStack", ".", "back", "(", ")", "==", "&", "MBB", ")", "{", "ExecBranchStack", ".", "pop_back", "(", ")", ";", "}", "if", "(", "HaveKill", "&&", "ExecBranchStack", ".", "empty", "(", ")", ")", "{", "HaveKill", "=", "false", ";", "}", "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", ":", "ExecBranchStack", ".", "push_back", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ";", "MadeChange", "|=", "skipMaskBranch", "(", "MI", ",", "MBB", ")", ";", "break", ";", "case", "AMDGPU", "::", "S_BRANCH", ":", "if", "(", "MBB", ".", "isLayoutSuccessor", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ")", "{", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "else", "if", "(", "HaveSkipBlock", ")", "{", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "break", ";", "case", "AMDGPU", "::", "SI_KILL_TERMINATOR", ":", "MadeChange", "=", "true", ";", "kill", "(", "MI", ")", ";", "if", "(", "ExecBranchStack", ".", "empty", "(", ")", ")", "{", "if", "(", "skipIfDead", "(", "MI", ",", "*", "NextBB", ")", ")", "{", "HaveSkipBlock", "=", "true", ";", "NextBB", "=", "std", "::", "next", "(", "BI", ")", ";", "BE", "=", "MF", ".", "end", "(", ")", ";", "}", "}", "else", "{", "HaveKill", "=", "true", ";", "}", "MI", ".", "eraseFromParent", "(", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_RETURN", ":", "assert", "(", "!", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "returnsVoid", "(", ")", ")", ";", "if", "(", "BI", "!=", "--", "MF", ".", "end", "(", ")", "||", "I", "!=", "MBB", ".", "getFirstTerminator", "(", ")", ")", "{", "if", "(", "!", "EmptyMBBAtEnd", ")", "{", "EmptyMBBAtEnd", "=", "MF", ".", "CreateMachineBasicBlock", "(", ")", ";", "MF", ".", "insert", "(", "MF", ".", "end", "(", ")", ",", "EmptyMBBAtEnd", ")", ";", "}", "MBB", ".", "addSuccessor", "(", "EmptyMBBAtEnd", ")", ";", "BuildMI", "(", "*", "BI", ",", "I", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_BRANCH", ")", ")", ".", "addMBB", "(", "EmptyMBBAtEnd", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "}", "break", ";", "default", ":", "break", ";", "}", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "16", "AMDGPU::SI_MASK_BRANCH", "0", "AMDGPU::S_BRANCH", "0", "AMDGPU::SI_KILL_TERMINATOR", "AMDGPU::SI_RETURN", "SI", "AMDGPU::S_BRANCH" ]

[]

[ "<s>", "bool", "AMDGPUSymbolizer", "::", "tryAddingSymbolicOperand", "(", "MCInst", "&", "Inst", ",", "raw_ostream", "&", ",", "int64_t", "Value", ",", "uint64_t", ",", "bool", "IsBranch", ",", "uint64_t", ",", "uint64_t", ",", "uint64_t", ")", "{", "if", "(", "!", "IsBranch", ")", "{", "return", "false", ";", "}", "auto", "*", "Symbols", "=", "static_cast", "<", "SectionSymbolsTy", "*", ">", "(", "DisInfo", ")", ";", "if", "(", "!", "Symbols", ")", "return", "false", ";", "auto", "Result", "=", "llvm", "::", "find_if", "(", "*", "Symbols", ",", "[", "Value", "]", "(", "const", "SymbolInfoTy", "&", "Val", ")", "{", "return", "Val", ".", "Addr", "==", "static_cast", "<", "uint64_t", ">", "(", "Value", ")", "&&", "Val", ".", "Type", "==", "ELF", "::", "STT_NOTYPE", ";", "}", ")", ";", "if", "(", "Result", "!=", "Symbols", "->", "end", "(", ")", ")", "{", "auto", "*", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "Result", "->", "Name", ")", ";", "const", "auto", "*", "Add", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "Ctx", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Add", ")", ")", ";", "return", "true", ";", "}", "ReferencedAddresses", ".", "push_back", "(", "static_cast", "<", "uint64_t", ">", "(", "Value", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

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

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

[ "GBZ80", "GB", "GB" ]

[]

[ "<s>", "static", "bool", "rs6000_debug_secondary_memory_needed", "(", "machine_mode", "mode", ",", "reg_class_t", "from_class", ",", "reg_class_t", "to_class", ")", "{", "bool", "ret", "=", "rs6000_secondary_memory_needed", "(", "mode", ",", "from_class", ",", "to_class", ")", ";", "fprintf", "(", "stderr", ",", "\"rs6000_secondary_memory_needed, return: %s, from_class = %s, \"", "\"to_class = %s, mode = %s\\n\"", ",", "ret", "?", "\"true\"", ":", "\"false\"", ",", "reg_class_names", "[", "from_class", "]", ",", "reg_class_names", "[", "to_class", "]", ",", "GET_MODE_NAME", "(", "mode", ")", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Debug", "version", "of", "rs6000_secondary_memory_needed", "." ]

[ "powerpcspe", "\"rs6000_secondary_memory_needed, return: %s, from_class = %s, \"", "\"to_class = %s, mode = %s\\n\"", "\"true\"", "\"false\"" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "emitFunctionBodyStart", "(", ")", "{", "MipsTargetStreamer", "&", "TS", "=", "getTargetStreamer", "(", ")", ";", "MCInstLowering", ".", "Initialize", "(", "&", "MF", "->", "getContext", "(", ")", ")", ";", "bool", "IsNakedFunction", "=", "MF", "->", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "Naked", ")", ";", "if", "(", "!", "IsNakedFunction", ")", "emitFrameDirective", "(", ")", ";", "if", "(", "!", "IsNakedFunction", ")", "printSavedRegsBitmask", "(", ")", ";", "if", "(", "!", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "{", "TS", ".", "emitDirectiveSetNoReorder", "(", ")", ";", "TS", ".", "emitDirectiveSetNoMacro", "(", ")", ";", "TS", ".", "emitDirectiveSetNoAt", "(", ")", ";", "}", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "emit", "stuff", "before", "the", "first", "basic", "block", "in", "the", "function", "." ]

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

[]

[ "<s>", "bool", "PPCLoopPreIncPrep", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "SE", "=", "&", "getAnalysis", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ".", "getSE", "(", ")", ";", "auto", "*", "DTWP", "=", "getAnalysisIfAvailable", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "DT", "=", "DTWP", "?", "&", "DTWP", "->", "getDomTree", "(", ")", ":", "nullptr", ";", "PreserveLCSSA", "=", "mustPreserveAnalysisID", "(", "LCSSAID", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "auto", "I", "=", "LI", "->", "begin", "(", ")", ",", "IE", "=", "LI", "->", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "for", "(", "auto", "L", "=", "df_begin", "(", "*", "I", ")", ",", "LE", "=", "df_end", "(", "*", "I", ")", ";", "L", "!=", "LE", ";", "++", "L", ")", "MadeChange", "|=", "runOnLoop", "(", "*", "L", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "void", "frv_optimize_membar_local", "(", "basic_block", "bb", ",", "struct", "frv_io", "*", "next_io", ",", "rtx", "*", "last_membar", ")", "{", "HARD_REG_SET", "used_regs", ";", "rtx", "next_membar", ",", "set", ",", "insn", ";", "bool", "next_is_end_p", ";", "memset", "(", "next_io", ",", "0", ",", "sizeof", "(", "*", "next_io", ")", ")", ";", "next_is_end_p", "=", "true", ";", "next_membar", "=", "0", ";", "CLEAR_HARD_REG_SET", "(", "used_regs", ")", ";", "for", "(", "insn", "=", "BB_END", "(", "bb", ")", ";", "insn", "!=", "BB_HEAD", "(", "bb", ")", ";", "insn", "=", "PREV_INSN", "(", "insn", ")", ")", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CALL_INSN", ")", "{", "memset", "(", "next_io", ",", "0", ",", "sizeof", "(", "struct", "frv_io", ")", ")", ";", "next_is_end_p", "=", "false", ";", "CLEAR_HARD_REG_SET", "(", "used_regs", ")", ";", "}", "else", "if", "(", "INSN_P", "(", "insn", ")", ")", "switch", "(", "recog_memoized", "(", "insn", ")", ")", "{", "case", "CODE_FOR_optional_membar_qi", ":", "case", "CODE_FOR_optional_membar_hi", ":", "case", "CODE_FOR_optional_membar_si", ":", "case", "CODE_FOR_optional_membar_di", ":", "next_membar", "=", "insn", ";", "if", "(", "next_is_end_p", ")", "{", "*", "last_membar", "=", "insn", ";", "frv_extract_membar", "(", "next_io", ",", "insn", ")", ";", "next_is_end_p", "=", "false", ";", "}", "else", "{", "struct", "frv_io", "prev_io", ";", "frv_extract_membar", "(", "&", "prev_io", ",", "insn", ")", ";", "if", "(", "frv_io_fixed_order_p", "(", "&", "prev_io", ",", "next_io", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; [Local] Removing membar %d since order\"", "\" of accesses is guaranteed\\n\"", ",", "INSN_UID", "(", "next_membar", ")", ")", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "delete_insn", "(", "next_membar", ")", ";", "next_membar", "=", "0", ";", "}", "*", "next_io", "=", "prev_io", ";", "}", "break", ";", "default", ":", "if", "(", "next_io", "->", "var_address", ")", "note_stores", "(", "PATTERN", "(", "insn", ")", ",", "frv_io_check_address", ",", "&", "next_io", "->", "var_address", ")", ";", "set", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "next_io", "->", "type", "==", "FRV_IO_READ", "&&", "next_io", "->", "var_address", "!=", "0", "&&", "next_membar", "!=", "0", "&&", "GET_CODE", "(", "set", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_DEST", "(", "set", ")", ")", "==", "REG", "&&", "TEST_HARD_REG_BIT", "(", "used_regs", ",", "REGNO", "(", "SET_DEST", "(", "set", ")", ")", ")", ")", "{", "rtx", "src", ";", "src", "=", "SET_SRC", "(", "set", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "ZERO_EXTEND", ")", "src", "=", "XEXP", "(", "src", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", "&&", "rtx_equal_p", "(", "XEXP", "(", "src", ",", "0", ")", ",", "next_io", "->", "var_address", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; [Local] Removing membar %d since the target\"", "\" of %d is used before the I/O operation\\n\"", ",", "INSN_UID", "(", "next_membar", ")", ",", "INSN_UID", "(", "insn", ")", ")", ";", "if", "(", "next_membar", "==", "*", "last_membar", ")", "*", "last_membar", "=", "0", ";", "delete_insn", "(", "next_membar", ")", ";", "next_membar", "=", "0", ";", "}", "}", "if", "(", "volatile_refs_p", "(", "PATTERN", "(", "insn", ")", ")", ")", "CLEAR_HARD_REG_SET", "(", "used_regs", ")", ";", "else", "note_stores", "(", "PATTERN", "(", "insn", ")", ",", "frv_io_handle_set", ",", "&", "used_regs", ")", ";", "note_uses", "(", "&", "PATTERN", "(", "insn", ")", ",", "frv_io_handle_use", ",", "&", "used_regs", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Go", "through", "block", "BB", "looking", "for", "membars", "to", "remove", ".", "There", "are", "two", "cases", "where", "intra-block", "analysis", "is", "enough", ":", "-", "a", "membar", "is", "redundant", "if", "it", "occurs", "between", "two", "consecutive", "I/O", "operations", "and", "if", "those", "operations", "are", "guaranteed", "to", "complete", "in", "order", ".", "-", "a", "membar", "for", "a", "__builtin_read", "is", "redundant", "if", "the", "result", "is", "used", "before", "the", "next", "I/O", "operation", "is", "issued", ".", "If", "the", "last", "membar", "in", "the", "block", "could", "not", "be", "removed", ",", "and", "there", "are", "guaranteed", "to", "be", "no", "I/O", "operations", "between", "that", "membar", "and", "the", "end", "of", "the", "block", ",", "store", "the", "membar", "in", "*", "LAST_MEMBAR", ",", "otherwise", "store", "null", ".", "Describe", "the", "block", "'s", "first", "I/O", "operation", "in", "*", "NEXT_IO", ".", "Describe", "an", "unknown", "operation", "if", "the", "block", "does", "n't", "do", "any", "I/O", "." ]

[ "frv", "0", "0", "0", "\";; [Local] Removing membar %d since order\"", "\" of accesses is guaranteed\\n\"", "0", "0", "0", "0", "0", "\";; [Local] Removing membar %d since the target\"", "\" of %d is used before the I/O operation\\n\"", "0", "0" ]

[]

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

[ "Returns", "true", "if", "the", "target", "wants", "to", "use", "frame", "pointer", "based", "accesses", "to", "spill", "to", "the", "scavenger", "emergency", "spill", "slot", "." ]

[ "Teak", "Teak" ]

[]

[ "<s>", "MCInstrDesc", "const", "&", "TPCMCInstrInfo", "::", "getDesc", "(", "MCInstrInfo", "const", "&", "MCII", ",", "MCInst", "const", "&", "MCI", ")", "{", "return", "(", "MCII", ".", "get", "(", "MCI", ".", "getOpcode", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Returns", "the", "target", "instruction", "descriptor", "of", "this", "MachineInstr", "." ]

[ "TPC", "TPC" ]

[]

[ "<s>", "static", "rtx", "mips_get_sync_operand", "(", "rtx", "*", "operands", ",", "int", "index", ",", "rtx", "default_value", ")", "{", "if", "(", "index", ">", "0", ")", "default_value", "=", "operands", "[", "index", "-", "1", "]", ";", "return", "default_value", ";", "}", "</s>" ]

[ "OPERANDS", "are", "the", "operands", "to", "a", "sync", "loop", "instruction", "and", "INDEX", "is", "the", "value", "of", "the", "one", "of", "the", "sync_", "*", "attributes", ".", "Return", "the", "operand", "referred", "to", "by", "the", "attribute", ",", "or", "DEFAULT_VALUE", "if", "the", "insn", "does", "n't", "have", "the", "associated", "attribute", "." ]

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

[]

[ "<s>", "bool", "ShouldShrinkFPConstant", "(", "EVT", "VT", ")", "const", "override", "{", "return", "!", "X86ScalarSSEf64", "||", "VT", "==", "MVT", "::", "f80", ";", "}", "</s>" ]

[ "If", "true", ",", "then", "instruction", "selection", "should", "seek", "to", "shrink", "the", "FP", "constant", "of", "the", "specified", "type", "to", "a", "smaller", "type", "in", "order", "to", "save", "space", "and", "/", "or", "reduce", "runtime", "." ]

[ "X86", "X86", "MVT::f80" ]

[]

[ "<s>", "int", "nds32_fp_as_gp_check_available", "(", "void", ")", "{", "return", "0", ";", "}", "</s>" ]

[ "Function", "to", "determine", "whether", "it", "is", "worth", "to", "do", "fp_as_gp", "optimization", ".", "Return", "0", ":", "It", "is", "NOT", "worth", "to", "do", "fp_as_gp", "optimization", ".", "Return", "1", ":", "It", "is", "APPROXIMATELY", "worth", "to", "do", "fp_as_gp", "optimization", ".", "Note", "that", "if", "it", "is", "worth", "to", "do", "fp_as_gp", "optimization", ",", "we", "MUST", "set", "FP_REGNUM", "ever", "live", "in", "this", "function", "." ]

[ "nds32", "0" ]

[]

[ "<s>", "bool", "PTXInstrInfo", "::", "SubsumesPredicate", "(", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Pred1", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Pred2", ")", "const", "{", "const", "MachineOperand", "&", "PredReg1", "=", "Pred1", "[", "0", "]", ";", "const", "MachineOperand", "&", "PredReg2", "=", "Pred2", "[", "0", "]", ";", "if", "(", "PredReg1", ".", "getReg", "(", ")", "!=", "PredReg2", ".", "getReg", "(", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "PredOp1", "=", "Pred1", "[", "1", "]", ";", "const", "MachineOperand", "&", "PredOp2", "=", "Pred2", "[", "1", "]", ";", "if", "(", "PredOp1", ".", "getImm", "(", ")", "!=", "PredOp2", ".", "getImm", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "first", "specified", "predicate", "subsumes", "the", "second", ",", "e.g", "." ]

[ "PTX", "PTX", "0", "0", "1", "1" ]

[]

[ "<s>", "bool", "gpr_or_gpr_p", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "return", "(", "(", "REG_P", "(", "op0", ")", "&&", "INT_REGNO_P", "(", "REGNO", "(", "op0", ")", ")", ")", "||", "(", "REG_P", "(", "op1", ")", "&&", "INT_REGNO_P", "(", "REGNO", "(", "op1", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "either", "operand", "is", "a", "general", "purpose", "register", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "createX86ExpandPseudoPass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

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

[]

[ "<s>", "bool", "Thumb2InstrInfo", "::", "isLegalToSplitMBBAt", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ")", "const", "{", "while", "(", "MBBI", "->", "isDebugInstr", "(", ")", ")", "{", "++", "MBBI", ";", "if", "(", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", "return", "false", ";", "}", "unsigned", "PredReg", "=", "0", ";", "return", "getITInstrPredicate", "(", "*", "MBBI", ",", "PredReg", ")", "==", "ARMCC", "::", "AL", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "legal", "to", "split", "the", "given", "basic", "block", "at", "the", "specified", "instruction", "(", "i.e", "." ]

[ "ARM", "0", "ARMCC::AL" ]

[]

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

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "PPCLinuxAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "const", "TargetData", "*", "TD", "=", "TM", ".", "getTargetData", "(", ")", ";", "bool", "isPPC64", "=", "TD", "->", "getPointerSizeInBits", "(", ")", "==", "64", ";", "if", "(", "isPPC64", "&&", "!", "TOC", ".", "empty", "(", ")", ")", "{", "const", "MCSectionELF", "*", "Section", "=", "OutStreamer", ".", "getContext", "(", ")", ".", "getELFSection", "(", "\".toc\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "Section", ")", ";", "for", "(", "DenseMap", "<", "MCSymbol", "*", ",", "MCSymbol", "*", ">", "::", "iterator", "I", "=", "TOC", ".", "begin", "(", ")", ",", "E", "=", "TOC", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "OutStreamer", ".", "EmitLabel", "(", "I", "->", "second", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "\"\\t.tc \"", "+", "Twine", "(", "I", "->", "first", "->", "getName", "(", ")", ")", "+", "\"[TC],\"", "+", "I", "->", "first", "->", "getName", "(", ")", ")", ";", "}", "}", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "PowerPC", "PPC", "PPC", "64", "PPC", "\".toc\"", "\"\\t.tc \"", "\"[TC],\"" ]

[]

[ "<s>", "static", "unsigned", "long", "arm_isr_value", "(", "tree", "argument", ")", "{", "const", "isr_attribute_arg", "*", "ptr", ";", "const", "char", "*", "arg", ";", "if", "(", "!", "arm_arch_notm", ")", "return", "ARM_FT_NORMAL", "|", "ARM_FT_STACKALIGN", ";", "if", "(", "argument", "==", "NULL_TREE", ")", "return", "ARM_FT_ISR", ";", "if", "(", "TREE_VALUE", "(", "argument", ")", "==", "NULL_TREE", "||", "TREE_CODE", "(", "TREE_VALUE", "(", "argument", ")", ")", "!=", "STRING_CST", ")", "return", "ARM_FT_UNKNOWN", ";", "arg", "=", "TREE_STRING_POINTER", "(", "TREE_VALUE", "(", "argument", ")", ")", ";", "for", "(", "ptr", "=", "isr_attribute_args", ";", "ptr", "->", "arg", "!=", "NULL", ";", "ptr", "++", ")", "if", "(", "streq", "(", "arg", ",", "ptr", "->", "arg", ")", ")", "return", "ptr", "->", "return_value", ";", "return", "ARM_FT_UNKNOWN", ";", "}", "</s>" ]

[ "Returns", "the", "(", "interrupt", ")", "function", "type", "of", "the", "current", "function", ",", "or", "ARM_FT_UNKNOWN", "if", "the", "type", "can", "not", "be", "determined", "." ]

[ "arm" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "CreateLiveInRegister", "(", "SelectionDAG", "&", "DAG", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Reg", ",", "EVT", "VT", ")", "const", "{", "SDValue", "VReg", "=", "AMDGPUTargetLowering", "::", "CreateLiveInRegister", "(", "DAG", ",", "RC", ",", "Reg", ",", "VT", ")", ";", "return", "DAG", ".", "getCopyFromReg", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "SDLoc", "(", "DAG", ".", "getEntryNode", "(", ")", ")", ",", "cast", "<", "RegisterSDNode", ">", "(", "VReg", ")", "->", "getReg", "(", ")", ",", "VT", ")", ";", "}", "</s>" ]

[ "Helper", "function", "that", "adds", "Reg", "to", "the", "LiveIn", "list", "of", "the", "DAG", "'s", "MachineFunction", "." ]

[ "R600", "SI" ]

[]

[ "<s>", "static", "bool", "arc_can_use_doloop_p", "(", "const", "widest_int", "&", ",", "const", "widest_int", "&", "iterations_max", ",", "unsigned", "int", "loop_depth", ",", "bool", "entered_at_top", ")", "{", "if", "(", "loop_depth", ">", "1", "||", "!", "entered_at_top", ")", "return", "false", ";", "if", "(", "arc_lpcwidth", "!=", "32", "&&", "(", "wi", "::", "gtu_p", "(", "iterations_max", ",", "(", "(", "1", "<<", "arc_lpcwidth", ")", "-", "1", ")", ")", "||", "wi", "::", "eq_p", "(", "iterations_max", ",", "0", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_USE_DOLOOP_P", "." ]

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

[]

[ "<s>", "const", "char", "*", "AArch64TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "AArch64ISD", "::", "BR_CC", ":", "return", "\"AArch64ISD::BR_CC\"", ";", "case", "AArch64ISD", "::", "Call", ":", "return", "\"AArch64ISD::Call\"", ";", "case", "AArch64ISD", "::", "FPMOV", ":", "return", "\"AArch64ISD::FPMOV\"", ";", "case", "AArch64ISD", "::", "GOTLoad", ":", "return", "\"AArch64ISD::GOTLoad\"", ";", "case", "AArch64ISD", "::", "BFI", ":", "return", "\"AArch64ISD::BFI\"", ";", "case", "AArch64ISD", "::", "EXTR", ":", "return", "\"AArch64ISD::EXTR\"", ";", "case", "AArch64ISD", "::", "Ret", ":", "return", "\"AArch64ISD::Ret\"", ";", "case", "AArch64ISD", "::", "SBFX", ":", "return", "\"AArch64ISD::SBFX\"", ";", "case", "AArch64ISD", "::", "SELECT_CC", ":", "return", "\"AArch64ISD::SELECT_CC\"", ";", "case", "AArch64ISD", "::", "SETCC", ":", "return", "\"AArch64ISD::SETCC\"", ";", "case", "AArch64ISD", "::", "TC_RETURN", ":", "return", "\"AArch64ISD::TC_RETURN\"", ";", "case", "AArch64ISD", "::", "THREAD_POINTER", ":", "return", "\"AArch64ISD::THREAD_POINTER\"", ";", "case", "AArch64ISD", "::", "TLSDESCCALL", ":", "return", "\"AArch64ISD::TLSDESCCALL\"", ";", "case", "AArch64ISD", "::", "WrapperLarge", ":", "return", "\"AArch64ISD::WrapperLarge\"", ";", "case", "AArch64ISD", "::", "WrapperSmall", ":", "return", "\"AArch64ISD::WrapperSmall\"", ";", "case", "AArch64ISD", "::", "NEON_BSL", ":", "return", "\"AArch64ISD::NEON_BSL\"", ";", "case", "AArch64ISD", "::", "NEON_MOVIMM", ":", "return", "\"AArch64ISD::NEON_MOVIMM\"", ";", "case", "AArch64ISD", "::", "NEON_MVNIMM", ":", "return", "\"AArch64ISD::NEON_MVNIMM\"", ";", "case", "AArch64ISD", "::", "NEON_FMOVIMM", ":", "return", "\"AArch64ISD::NEON_FMOVIMM\"", ";", "case", "AArch64ISD", "::", "NEON_CMP", ":", "return", "\"AArch64ISD::NEON_CMP\"", ";", "case", "AArch64ISD", "::", "NEON_CMPZ", ":", "return", "\"AArch64ISD::NEON_CMPZ\"", ";", "case", "AArch64ISD", "::", "NEON_TST", ":", "return", "\"AArch64ISD::NEON_TST\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64ISD::BR_CC", "\"AArch64ISD::BR_CC\"", "AArch64ISD::Call", "\"AArch64ISD::Call\"", "AArch64ISD::FPMOV", "\"AArch64ISD::FPMOV\"", "AArch64ISD::GOTLoad", "\"AArch64ISD::GOTLoad\"", "AArch64ISD::BFI", "\"AArch64ISD::BFI\"", "AArch64ISD::EXTR", "\"AArch64ISD::EXTR\"", "AArch64ISD::Ret", "\"AArch64ISD::Ret\"", "AArch64ISD::SBFX", "\"AArch64ISD::SBFX\"", "AArch64ISD::SELECT_CC", "\"AArch64ISD::SELECT_CC\"", "AArch64ISD::SETCC", "\"AArch64ISD::SETCC\"", "AArch64ISD::TC_RETURN", "\"AArch64ISD::TC_RETURN\"", "AArch64ISD::THREAD_POINTER", "\"AArch64ISD::THREAD_POINTER\"", "AArch64ISD::TLSDESCCALL", "\"AArch64ISD::TLSDESCCALL\"", "AArch64ISD::WrapperLarge", "\"AArch64ISD::WrapperLarge\"", "AArch64ISD::WrapperSmall", "\"AArch64ISD::WrapperSmall\"", "AArch64ISD::NEON_BSL", "\"AArch64ISD::NEON_BSL\"", "AArch64ISD::NEON_MOVIMM", "\"AArch64ISD::NEON_MOVIMM\"", "AArch64ISD::NEON_MVNIMM", "\"AArch64ISD::NEON_MVNIMM\"", "AArch64ISD::NEON_FMOVIMM", "\"AArch64ISD::NEON_FMOVIMM\"", "AArch64ISD::NEON_CMP", "\"AArch64ISD::NEON_CMP\"", "AArch64ISD::NEON_CMPZ", "\"AArch64ISD::NEON_CMPZ\"", "AArch64ISD::NEON_TST", "\"AArch64ISD::NEON_TST\"" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "shouldSink", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "isPredicated", "(", "MI", ")", ")", "return", "true", ";", "MachineBasicBlock", "::", "const_iterator", "Next", "=", "&", "MI", ";", "++", "Next", ";", "Register", "SrcReg", ",", "SrcReg2", ";", "int", "CmpMask", ",", "CmpValue", ";", "bool", "IsThumb1", ";", "if", "(", "Next", "!=", "MI", ".", "getParent", "(", ")", "->", "end", "(", ")", "&&", "analyzeCompare", "(", "*", "Next", ",", "SrcReg", ",", "SrcReg2", ",", "CmpMask", ",", "CmpValue", ")", "&&", "isRedundantFlagInstr", "(", "&", "*", "Next", ",", "SrcReg", ",", "SrcReg2", ",", "CmpValue", ",", "&", "MI", ",", "IsThumb1", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "should", "be", "sunk", "by", "MachineSink", "." ]

[ "ARM", "ARM" ]

[]

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

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

[ "X86", "X86" ]

[]

[ "<s>", "static", "bool", "in_same_chain", "(", "rtx_insn", "*", "insn", ",", "rtx_insn", "*", "cand", ",", "unsigned", "regno", ")", "{", "struct", "du_chain", "*", "chain", "=", "NULL", ";", "du_head_p", "head", "=", "NULL", ";", "int", "i", ";", "operand_rr_info", "*", "op_info", "=", "insn_rr", "[", "INSN_UID", "(", "insn", ")", "]", ".", "op_info", ";", "for", "(", "i", "=", "0", ";", "i", "<", "op_info", "->", "n_chains", ";", "i", "++", ")", "{", "if", "(", "op_info", "->", "heads", "[", "i", "]", "->", "regno", "!=", "regno", ")", "continue", ";", "head", "=", "op_info", "->", "heads", "[", "i", "]", ";", "if", "(", "!", "head", "->", "first", ")", "head", "=", "regrename_chain_from_id", "(", "head", "->", "id", ")", ";", "bool", "found_insn", "=", "false", ",", "found_cand", "=", "false", ";", "for", "(", "chain", "=", "head", "->", "first", ";", "chain", ";", "chain", "=", "chain", "->", "next_use", ")", "{", "rtx", "*", "loc", "=", "&", "SET_DEST", "(", "PATTERN", "(", "chain", "->", "insn", ")", ")", ";", "if", "(", "chain", "->", "loc", "!=", "loc", ")", "continue", ";", "if", "(", "chain", "->", "insn", "==", "insn", ")", "found_insn", "=", "true", ";", "if", "(", "chain", "->", "insn", "==", "cand", ")", "found_cand", "=", "true", ";", "if", "(", "found_insn", "&&", "found_cand", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "whether", "INSN", "and", "CAND", "are", "in", "the", "same", "def/use", "chain", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "void", "HSAILMachineFunctionInfo", "::", "addMetadata", "(", "std", "::", "string", "md", ",", "bool", "kernelOnly", ")", "{", "if", "(", "kernelOnly", ")", "{", "mMetadataKernel", ".", "push_back", "(", "md", ")", ";", "}", "else", "{", "mMetadataFunc", ".", "insert", "(", "md", ")", ";", "}", "}", "</s>" ]

[ "Similar", "to", "the", "previous", "function", "but", "it", "adds", "the", "metadata", "to", "a", "vector", "of", "instructions", "." ]

[ "HSAIL", "HSAIL" ]

[]

[ "<s>", "static", "void", "alpha_output_mi_thunk_osf", "(", "FILE", "*", "file", ",", "tree", "thunk_fndecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "HOST_WIDE_INT", "hi", ",", "lo", ";", "rtx", "this_rtx", ",", "funexp", ";", "rtx_insn", "*", "insn", ";", "emit_insn", "(", "gen_prologue_ldgp", "(", ")", ")", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "17", ")", ";", "else", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "16", ")", ";", "lo", "=", "(", "(", "delta", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "hi", "=", "(", "(", "(", "delta", "-", "lo", ")", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "if", "(", "hi", "+", "lo", "==", "delta", ")", "{", "if", "(", "hi", ")", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "GEN_INT", "(", "hi", ")", ")", ")", ";", "if", "(", "lo", ")", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "GEN_INT", "(", "lo", ")", ")", ")", ";", "}", "else", "{", "rtx", "tmp", "=", "alpha_emit_set_long_const", "(", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ",", "delta", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "tmp", ")", ")", ";", "}", "if", "(", "vcall_offset", ")", "{", "rtx", "tmp", ",", "tmp2", ";", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "this_rtx", ")", ")", ";", "lo", "=", "(", "(", "vcall_offset", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "hi", "=", "(", "(", "(", "vcall_offset", "-", "lo", ")", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "if", "(", "hi", "+", "lo", "==", "vcall_offset", ")", "{", "if", "(", "hi", ")", "emit_insn", "(", "gen_adddi3", "(", "tmp", ",", "tmp", ",", "GEN_INT", "(", "hi", ")", ")", ")", ";", "}", "else", "{", "tmp2", "=", "alpha_emit_set_long_const", "(", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ",", "vcall_offset", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "tmp", ",", "tmp", ",", "tmp2", ")", ")", ";", "lo", "=", "0", ";", "}", "if", "(", "lo", ")", "tmp2", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tmp", ",", "GEN_INT", "(", "lo", ")", ")", ";", "else", "tmp2", "=", "tmp", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "tmp2", ")", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "tmp", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "1", ";", "}", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "funexp", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "funexp", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "funexp", ",", "const0_rtx", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "get_insns", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "}", "</s>" ]

[ "Emit", "a", "tail", "call", "to", "FUNCTION", "after", "adjusting", "THIS", "by", "DELTA", ".", "In", "order", "to", "avoid", "the", "hordes", "of", "differences", "between", "generated", "code", "with", "and", "without", "TARGET_EXPLICIT_RELOCS", ",", "and", "to", "avoid", "duplicating", "lots", "of", "code", "loading", "up", "large", "constants", ",", "generate", "rtl", "and", "emit", "it", "instead", "of", "going", "straight", "to", "text", ".", "Not", "sure", "why", "this", "idea", "has", "n't", "been", "explored", "before", "..." ]

[ "alpha", "17", "16", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "0", "0", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "1", "0", "1", "0", "1", "1", "1" ]

[]

[ "<s>", "static", "bool", "frv_same_doubleword_p", "(", "const", "struct", "frv_io", "*", "io1", ",", "const", "struct", "frv_io", "*", "io2", ")", "{", "if", "(", "io1", "->", "const_address", "!=", "0", "&&", "io2", "->", "const_address", "!=", "0", ")", "return", "io1", "->", "const_address", "==", "io2", "->", "const_address", ";", "if", "(", "io1", "->", "var_address", "!=", "0", "&&", "io2", "->", "var_address", "!=", "0", ")", "return", "rtx_equal_p", "(", "io1", "->", "var_address", ",", "io2", "->", "var_address", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "accesses", "IO1", "and", "IO2", "refer", "to", "the", "same", "doubleword", "." ]

[ "frv", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "altivec_expand_stvex_be", "(", "rtx", "op0", ",", "rtx", "op1", ",", "machine_mode", "mode", ",", "unsigned", "unspec", ")", "{", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "rtx", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "stvx", "=", "gen_rtx_UNSPEC", "(", "inner_mode", ",", "gen_rtvec", "(", "1", ",", "tmp", ")", ",", "unspec", ")", ";", "rtx", "sel", "=", "swap_selector_for_mode", "(", "mode", ")", ";", "rtx", "vperm", ";", "gcc_assert", "(", "REG_P", "(", "op1", ")", ")", ";", "vperm", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "op1", ",", "op1", ",", "sel", ")", ",", "UNSPEC_VPERM", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "tmp", ",", "vperm", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "op0", ",", "stvx", ")", ")", ";", "}", "</s>" ]

[ "Generate", "code", "for", "a", "``", "stve", "*", "x", "''", "built-in", "for", "a", "little", "endian", "target", "with", "-maltivec=be", "specified", ".", "Issue", "the", "store", "preceded", "by", "an", "element-reversing", "permute", "." ]

[ "rs6000", "1", "3" ]

[]

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

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

[ "AVR", "AVR" ]

[]

[ "<s>", "static", "const", "char", "*", "rs6000_xcoff_visibility", "(", "tree", "decl", ")", "{", "static", "const", "char", "*", "const", "visibility_types", "[", "]", "=", "{", "\"\"", ",", "\",protected\"", ",", "\",hidden\"", ",", "\",internal\"", "}", ";", "enum", "symbol_visibility", "vis", "=", "DECL_VISIBILITY", "(", "decl", ")", ";", "return", "visibility_types", "[", "vis", "]", ";", "}", "</s>" ]

[ "Helper", "function", "to", "calculate", "visibility", "of", "a", "DECL", "and", "return", "the", "value", "as", "a", "const", "string", "." ]

[ "rs6000", "\"\"", "\",protected\"", "\",hidden\"", "\",internal\"" ]

[]

[ "<s>", "tree", "gimple_folder", "::", "fold_contiguous_base", "(", "gimple_seq", "&", "stmts", ",", "tree", "vectype", ")", "{", "tree", "base", "=", "gimple_call_arg", "(", "call", ",", "1", ")", ";", "if", "(", "mode_suffix_id", "==", "MODE_vnum", ")", "{", "tree", "offset", "=", "gimple_call_arg", "(", "call", ",", "2", ")", ";", "offset", "=", "gimple_convert", "(", "&", "stmts", ",", "sizetype", ",", "offset", ")", ";", "offset", "=", "gimple_build", "(", "&", "stmts", ",", "MULT_EXPR", ",", "sizetype", ",", "offset", ",", "TYPE_SIZE_UNIT", "(", "vectype", ")", ")", ";", "base", "=", "gimple_build", "(", "&", "stmts", ",", "POINTER_PLUS_EXPR", ",", "TREE_TYPE", "(", "base", ")", ",", "base", ",", "offset", ")", ";", "}", "return", "base", ";", "}", "</s>" ]

[ "Return", "a", "pointer", "to", "the", "address", "in", "a", "contiguous", "load", "or", "store", ",", "given", "that", "each", "memory", "vector", "has", "type", "VECTYPE", ".", "Add", "any", "new", "statements", "to", "STMTS", "." ]

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

[]

[ "<s>", "static", "void", "mips_atomic_assign_expand_fenv", "(", "tree", "*", "hold", ",", "tree", "*", "clear", ",", "tree", "*", "update", ")", "{", "if", "(", "!", "TARGET_HARD_FLOAT_ABI", ")", "return", ";", "tree", "exceptions_var", "=", "create_tmp_var", "(", "MIPS_ATYPE_USI", ")", ";", "tree", "fcsr_orig_var", "=", "create_tmp_var", "(", "MIPS_ATYPE_USI", ")", ";", "tree", "fcsr_mod_var", "=", "create_tmp_var", "(", "MIPS_ATYPE_USI", ")", ";", "tree", "get_fcsr", "=", "mips_builtin_decls", "[", "MIPS_GET_FCSR", "]", ";", "tree", "set_fcsr", "=", "mips_builtin_decls", "[", "MIPS_SET_FCSR", "]", ";", "tree", "get_fcsr_hold_call", "=", "build_call_expr", "(", "get_fcsr", ",", "0", ")", ";", "tree", "hold_assign_orig", "=", "build2", "(", "MODIFY_EXPR", ",", "MIPS_ATYPE_USI", ",", "fcsr_orig_var", ",", "get_fcsr_hold_call", ")", ";", "tree", "hold_mod_val", "=", "build2", "(", "BIT_AND_EXPR", ",", "MIPS_ATYPE_USI", ",", "fcsr_orig_var", ",", "build_int_cst", "(", "MIPS_ATYPE_USI", ",", "0xfffff003", ")", ")", ";", "tree", "hold_assign_mod", "=", "build2", "(", "MODIFY_EXPR", ",", "MIPS_ATYPE_USI", ",", "fcsr_mod_var", ",", "hold_mod_val", ")", ";", "tree", "set_fcsr_hold_call", "=", "build_call_expr", "(", "set_fcsr", ",", "1", ",", "fcsr_mod_var", ")", ";", "tree", "hold_all", "=", "build2", "(", "COMPOUND_EXPR", ",", "MIPS_ATYPE_USI", ",", "hold_assign_orig", ",", "hold_assign_mod", ")", ";", "*", "hold", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "hold_all", ",", "set_fcsr_hold_call", ")", ";", "*", "clear", "=", "build_call_expr", "(", "set_fcsr", ",", "1", ",", "fcsr_mod_var", ")", ";", "tree", "get_fcsr_update_call", "=", "build_call_expr", "(", "get_fcsr", ",", "0", ")", ";", "*", "update", "=", "build2", "(", "MODIFY_EXPR", ",", "MIPS_ATYPE_USI", ",", "exceptions_var", ",", "get_fcsr_update_call", ")", ";", "tree", "set_fcsr_update_call", "=", "build_call_expr", "(", "set_fcsr", ",", "1", ",", "fcsr_orig_var", ")", ";", "*", "update", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "*", "update", ",", "set_fcsr_update_call", ")", ";", "tree", "atomic_feraiseexcept", "=", "builtin_decl_implicit", "(", "BUILT_IN_ATOMIC_FERAISEEXCEPT", ")", ";", "tree", "int_exceptions_var", "=", "fold_convert", "(", "integer_type_node", ",", "exceptions_var", ")", ";", "tree", "atomic_feraiseexcept_call", "=", "build_call_expr", "(", "atomic_feraiseexcept", ",", "1", ",", "int_exceptions_var", ")", ";", "*", "update", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "*", "update", ",", "atomic_feraiseexcept_call", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ATOMIC_ASSIGN_EXPAND_FENV", "." ]

[ "mips", "0", "0xfffff003", "1", "1", "0", "1", "1" ]

[]

[ "<s>", "int", "xstormy16_below100_symbol", "(", "rtx", "x", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "return", "(", "SYMBOL_REF_FLAGS", "(", "x", ")", "&", "SYMBOL_FLAG_XSTORMY16_BELOW100", ")", "!=", "0", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "{", "HOST_WIDE_INT", "i", "=", "INTVAL", "(", "x", ")", ";", "if", "(", "(", "i", ">=", "0x0000", "&&", "i", "<=", "0x00ff", ")", "||", "(", "i", ">=", "0x7f00", "&&", "i", "<=", "0x7fff", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Predicate", "for", "symbols", "and", "addresses", "that", "reflect", "special", "8-bit", "addressing", "." ]

[ "stormy16", "0", "1", "0", "0", "0x0000", "0x00ff", "0x7f00", "0x7fff", "1", "0" ]

[]

[ "<s>", "void", "StackFixup", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "llvm", "::", "for_each", "(", "Changes", ",", "[", "&", "]", "(", "const", "std", "::", "pair", "<", "Change", ",", "std", "::", "string", ">", "&", "v", ")", "{", "printElem", "(", "OS", ",", "v", ".", "first", ")", ";", "OS", "<<", "\"; \"", "<<", "v", ".", "second", "<<", "\"\\n\"", ";", "}", ")", ";", "}", "</s>" ]

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

[ "TVM", "\"; \"", "\"\\n\"" ]

[]

[ "<s>", "static", "rtx", "ix86_expand_int_compare", "(", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "cmpmode", ";", "rtx", "tmp", ",", "flags", ";", "if", "(", "(", "code", "==", "GTU", "||", "code", "==", "LEU", ")", "&&", "nonimmediate_operand", "(", "op1", ",", "VOIDmode", ")", ")", "{", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "}", "cmpmode", "=", "SELECT_CC_MODE", "(", "code", ",", "op0", ",", "op1", ")", ";", "flags", "=", "gen_rtx_REG", "(", "cmpmode", ",", "FLAGS_REG", ")", ";", "tmp", "=", "gen_rtx_COMPARE", "(", "cmpmode", ",", "op0", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "flags", ",", "tmp", ")", ")", ";", "return", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "flags", ",", "const0_rtx", ")", ";", "}", "</s>" ]

[ "Generate", "insn", "patterns", "to", "do", "an", "integer", "compare", "of", "OPERANDS", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "XCoreTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "Context", ")", ";", "if", "(", "!", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_XCore", ")", ")", "return", "false", ";", "if", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", "!=", "0", "&&", "isVarArg", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "XCore", "XCore", "ISD::OutputArg", "16", "XCore", "0" ]

[]

[ "<s>", "void", "HexagonDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "return", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "Constant", ":", "return", "SelectConstant", "(", "N", ")", ";", "case", "ISD", "::", "ConstantFP", ":", "return", "SelectConstantFP", "(", "N", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "SelectFrameIndex", "(", "N", ")", ";", "case", "ISD", "::", "BITCAST", ":", "return", "SelectBitcast", "(", "N", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "SelectSHL", "(", "N", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "SelectLoad", "(", "N", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "SelectStore", "(", "N", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "SelectIntrinsicWChain", "(", "N", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "SelectIntrinsicWOChain", "(", "N", ")", ";", "case", "HexagonISD", "::", "TYPECAST", ":", "return", "SelectTypecast", "(", "N", ")", ";", "case", "HexagonISD", "::", "P2D", ":", "return", "SelectP2D", "(", "N", ")", ";", "case", "HexagonISD", "::", "D2P", ":", "return", "SelectD2P", "(", "N", ")", ";", "case", "HexagonISD", "::", "Q2V", ":", "return", "SelectQ2V", "(", "N", ")", ";", "case", "HexagonISD", "::", "V2Q", ":", "return", "SelectV2Q", "(", "N", ")", ";", "}", "if", "(", "HST", "->", "useHVXOps", "(", ")", ")", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "SelectHvxShuffle", "(", "N", ")", ";", "case", "HexagonISD", "::", "VROR", ":", "return", "SelectHvxRor", "(", "N", ")", ";", "}", "}", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "1", "ISD::Constant", "ISD::ConstantFP", "ISD::FrameIndex", "ISD::BITCAST", "ISD::SHL", "ISD::LOAD", "ISD::STORE", "ISD::INTRINSIC_W_CHAIN", "ISD::INTRINSIC_WO_CHAIN", "HexagonISD::TYPECAST", "HexagonISD::P2D", "HexagonISD::D2P", "HexagonISD::Q2V", "HexagonISD::V2Q", "ISD::VECTOR_SHUFFLE", "HexagonISD::VROR" ]

[]

[ "<s>", "size_type", "count", "(", ")", "const", "{", "return", "V", ".", "count", "(", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "the", "specified", "key", "is", "in", "the", "map", ",", "0", "otherwise", "." ]

[ "X86" ]

[]

[ "<s>", "static", "void", "avr_option_override", "(", "void", ")", "{", "if", "(", "avr_strict_X", ")", "flag_caller_saves", "=", "0", ";", "if", "(", "(", "flag_unwind_tables", "||", "flag_non_call_exceptions", "||", "flag_asynchronous_unwind_tables", ")", "&&", "!", "ACCUMULATE_OUTGOING_ARGS", ")", "{", "flag_omit_frame_pointer", "=", "0", ";", "}", "if", "(", "flag_pic", "==", "1", ")", "warning", "(", "OPT_fpic", ",", "\"%<-fpic%> is not supported\"", ")", ";", "if", "(", "flag_pic", "==", "2", ")", "warning", "(", "OPT_fPIC", ",", "\"%<-fPIC%> is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "1", ")", "warning", "(", "OPT_fpie", ",", "\"%<-fpie%> is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "2", ")", "warning", "(", "OPT_fPIE", ",", "\"%<-fPIE%> is not supported\"", ")", ";", "avr_gasisr_prologues", "=", "0", ";", "if", "(", "!", "avr_set_core_architecture", "(", ")", ")", "return", ";", "gcc_assert", "(", "avr_long_double", ">=", "avr_double", "&&", "avr_double", ">=", "32", ")", ";", "avr_addr", ".", "sreg", "=", "0x3F", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampz", "=", "0x3B", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampy", "=", "0x3A", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampx", "=", "0x39", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampd", "=", "0x38", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "ccp", "=", "(", "AVR_TINY", "?", "0x3C", ":", "0x34", ")", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "sp_l", "=", "0x3D", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "sp_h", "=", "avr_addr", ".", "sp_l", "+", "1", ";", "init_machine_status", "=", "avr_init_machine_status", ";", "avr_log_set_avr_log", "(", ")", ";", "}", "</s>" ]

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

[ "avr", "0", "0", "1", "\"%<-fpic%> is not supported\"", "2", "\"%<-fPIC%> is not supported\"", "1", "\"%<-fpie%> is not supported\"", "2", "\"%<-fPIE%> is not supported\"", "0", "32", "0x3F", "0x3B", "0x3A", "0x39", "0x38", "0x3C", "0x34", "0x3D", "1" ]

[]

[ "<s>", "static", "void", "m68k_output_dwarf_dtprel", "(", "FILE", "*", "file", ",", "int", "size", ",", "rtx", "x", ")", "{", "gcc_assert", "(", "size", "==", "4", ")", ";", "fputs", "(", "\"\\t.long\\t\"", ",", "file", ")", ";", "output_addr_const", "(", "file", ",", "x", ")", ";", "fputs", "(", "\"@TLSLDO+0x8000\"", ",", "file", ")", ";", "}", "</s>" ]

[ "M68K", "implementation", "of", "TARGET_ASM_OUTPUT_DWARF_DTPREL", "." ]

[ "m68k", "4", "\"\\t.long\\t\"", "\"@TLSLDO+0x8000\"" ]

[]

[ "<s>", "static", "bool", "abi_v4_pass_in_fpr", "(", "machine_mode", "mode", ",", "bool", "named", ")", "{", "if", "(", "!", "TARGET_HARD_FLOAT", ")", "return", "false", ";", "if", "(", "mode", "==", "DFmode", ")", "return", "true", ";", "if", "(", "mode", "==", "SFmode", "&&", "named", ")", "return", "true", ";", "if", "(", "is_complex_IBM_long_double", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "FLOAT128_2REG_P", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Whether", "ABI_V4", "passes", "MODE", "args", "to", "a", "function", "in", "floating", "point", "registers", "." ]

[ "rs6000" ]

[]

[ "<s>", "rtx", "aarch64_replace_reg_mode", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE", "(", "x", ")", "==", "mode", ")", "return", "x", ";", "x", "=", "shallow_copy_rtx", "(", "x", ")", ";", "set_mode_and_regno", "(", "x", ",", "mode", ",", "REGNO", "(", "x", ")", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "Return", "a", "copy", "of", "X", "with", "mode", "MODE", ",", "without", "changing", "its", "other", "attributes", ".", "Unlike", "gen_lowpart", ",", "this", "does", "n't", "care", "whether", "the", "mode", "change", "is", "valid", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "SPUPassConfig", "::", "addInstSelector", "(", ")", "{", "PM", ".", "add", "(", "createSPUISelDag", "(", "getSPUTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "SPU", "SPU" ]

[]

[ "<s>", "void", "PTXInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DstReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "for", "(", "int", "i", "=", "0", ",", "e", "=", "sizeof", "(", "map", ")", "/", "sizeof", "(", "map", "[", "0", "]", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "map", "[", "i", "]", ".", "cls", "->", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "map", "[", "i", "]", ".", "opcode", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "}", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "0", "0", "\"Impossible reg-to-reg copy\"" ]

[]

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

[ "Returns", "true", "if", "the", "target", "wants", "to", "use", "frame", "pointer", "based", "accesses", "to", "spill", "to", "the", "scavenger", "emergency", "spill", "slot", "." ]

[ "XCore", "XCore" ]

[]

[ "<s>", "bool", "MSP430AsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "Loc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "Inst", ".", "setLoc", "(", "Loc", ")", ";", "Out", ".", "emitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "Loc", ",", "\"invalid instruction mnemonic\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "Loc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "ErrorLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "MSP430Operand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "Loc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "\"invalid instruction mnemonic\"", "0U", "\"too few operands for instruction\"", "MSP430", "\"invalid operand for instruction\"" ]

[]

[ "<s>", "static", "void", "aarch64_expand_vec_series", "(", "rtx", "dest", ",", "rtx", "base", ",", "rtx", "step", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "scalar_mode", "inner", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "if", "(", "!", "aarch64_sve_index_immediate_p", "(", "base", ")", ")", "base", "=", "force_reg", "(", "inner", ",", "base", ")", ";", "if", "(", "!", "aarch64_sve_index_immediate_p", "(", "step", ")", ")", "step", "=", "force_reg", "(", "inner", ",", "step", ")", ";", "emit_set_insn", "(", "dest", ",", "gen_rtx_VEC_SERIES", "(", "mode", ",", "base", ",", "step", ")", ")", ";", "}", "</s>" ]

[ "Set", "DEST", "to", "(", "vec_series", "BASE", "STEP", ")", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "void", "aarch64_init_fpsr_fpcr_builtins", "(", "void", ")", "{", "tree", "ftype_set", "=", "build_function_type_list", "(", "void_type_node", ",", "unsigned_type_node", ",", "NULL", ")", ";", "tree", "ftype_get", "=", "build_function_type_list", "(", "unsigned_type_node", ",", "NULL", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_GET_FPCR", "]", "=", "aarch64_general_add_builtin", "(", "\"__builtin_aarch64_get_fpcr\"", ",", "ftype_get", ",", "AARCH64_BUILTIN_GET_FPCR", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_SET_FPCR", "]", "=", "aarch64_general_add_builtin", "(", "\"__builtin_aarch64_set_fpcr\"", ",", "ftype_set", ",", "AARCH64_BUILTIN_SET_FPCR", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_GET_FPSR", "]", "=", "aarch64_general_add_builtin", "(", "\"__builtin_aarch64_get_fpsr\"", ",", "ftype_get", ",", "AARCH64_BUILTIN_GET_FPSR", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_SET_FPSR", "]", "=", "aarch64_general_add_builtin", "(", "\"__builtin_aarch64_set_fpsr\"", ",", "ftype_set", ",", "AARCH64_BUILTIN_SET_FPSR", ")", ";", "ftype_set", "=", "build_function_type_list", "(", "void_type_node", ",", "long_long_unsigned_type_node", ",", "NULL", ")", ";", "ftype_get", "=", "build_function_type_list", "(", "long_long_unsigned_type_node", ",", "NULL", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_GET_FPCR64", "]", "=", "aarch64_general_add_builtin", "(", "\"__builtin_aarch64_get_fpcr64\"", ",", "ftype_get", ",", "AARCH64_BUILTIN_GET_FPCR64", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_SET_FPCR64", "]", "=", "aarch64_general_add_builtin", "(", "\"__builtin_aarch64_set_fpcr64\"", ",", "ftype_set", ",", "AARCH64_BUILTIN_SET_FPCR64", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_GET_FPSR64", "]", "=", "aarch64_general_add_builtin", "(", "\"__builtin_aarch64_get_fpsr64\"", ",", "ftype_get", ",", "AARCH64_BUILTIN_GET_FPSR64", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_SET_FPSR64", "]", "=", "aarch64_general_add_builtin", "(", "\"__builtin_aarch64_set_fpsr64\"", ",", "ftype_set", ",", "AARCH64_BUILTIN_SET_FPSR64", ")", ";", "}", "</s>" ]

[ "Initialize", "fpsr", "fpcr", "getters", "and", "setters", "." ]

[ "aarch64", "\"__builtin_aarch64_get_fpcr\"", "\"__builtin_aarch64_set_fpcr\"", "\"__builtin_aarch64_get_fpsr\"", "\"__builtin_aarch64_set_fpsr\"", "\"__builtin_aarch64_get_fpcr64\"", "\"__builtin_aarch64_set_fpcr64\"", "\"__builtin_aarch64_get_fpsr64\"", "\"__builtin_aarch64_set_fpsr64\"" ]

[]

[ "<s>", "SDValue", "XCoreSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "bool", "AlwaysInline", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "unsigned", "SizeBitWidth", "=", "Size", ".", "getValueType", "(", ")", ".", "getSizeInBits", "(", ")", ";", "if", "(", "!", "AlwaysInline", "&&", "(", "Align", "&", "3", ")", "==", "0", "&&", "DAG", ".", "MaskedValueIsZero", "(", "Size", ",", "APInt", "(", "SizeBitWidth", ",", "3", ")", ")", ")", "{", "const", "TargetLowering", "&", "TLI", "=", "*", "DAG", ".", "getSubtarget", "(", ")", ".", "getTargetLowering", "(", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Entry", ".", "Ty", "=", "DAG", ".", "getDataLayout", "(", ")", ".", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";", "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "Chain", ")", ".", "setCallee", "(", "TLI", ".", "getLibcallCallingConv", "(", "RTLIB", "::", "MEMCPY", ")", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "DAG", ".", "getExternalSymbol", "(", "\"__memcpy_4\"", ",", "TLI", ".", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ",", "std", "::", "move", "(", "Args", ")", ",", "0", ")", ".", "setDiscardResult", "(", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memcpy", "." ]

[ "XCore", "XCore", "3", "0", "3", "\"__memcpy_4\"", "0" ]

[]

[ "<s>", "void", "ARCExpandPseudos", "::", "expandCTTZ", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "::", "iterator", "MII", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MII", ";", "const", "MachineOperand", "&", "Dest", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "const", "MachineOperand", "&", "Src", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "Register", "R", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "ARC", "::", "GPR32RegClass", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ARC", "::", "FFS_f_rr", ")", ",", "R", ")", ".", "add", "(", "Src", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ARC", "::", "MOV_cc_ru6", ")", ")", ".", "add", "(", "Dest", ")", ".", "addImm", "(", "32", ")", ".", "addImm", "(", "ARCCC", "::", "EQ", ")", ".", "addReg", "(", "R", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "</s>" ]

[ "Expand", "CTTZ/CTTZ_ZERO_UNDEF", "nodes", "." ]

[ "ARC", "ARC", "0", "1", "ARC::GPR32RegClass", "ARC::FFS_f_rr", "ARC::MOV_cc_ru6", "32", "ARCCC::EQ" ]

[]

[ "<s>", "static", "bool", "sp_valid_at", "(", "HOST_WIDE_INT", "cfa_offset", ")", "{", "const", "struct", "machine_frame_state", "&", "fs", "=", "cfun", "->", "machine", "->", "fs", ";", "if", "(", "fs", ".", "sp_realigned", "&&", "cfa_offset", "<=", "fs", ".", "sp_realigned_offset", ")", "{", "gcc_assert", "(", "cfa_offset", "<=", "fs", ".", "sp_realigned_fp_last", ")", ";", "return", "false", ";", "}", "return", "fs", ".", "sp_valid", ";", "}", "</s>" ]

[ "Determine", "if", "the", "stack", "pointer", "is", "valid", "for", "accessing", "the", "CFA_OFFSET", "in", "the", "frame", "save", "area", ".", "The", "register", "is", "saved", "at", "CFA", "-", "CFA_OFFSET", "." ]

[ "i386" ]

[]

[ "<s>", "static", "bool", "arc_rtx_costs", "(", "rtx", "x", ",", "int", "code", ",", "int", "outer_code", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", ")", "{", "switch", "(", "code", ")", "{", "case", "CONST_INT", ":", "if", "(", "SMALL_INT", "(", "INTVAL", "(", "x", ")", ")", ")", "{", "*", "total", "=", "0", ";", "return", "true", ";", "}", "case", "CONST", ":", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "true", ";", "case", "CONST_DOUBLE", ":", "{", "rtx", "high", ",", "low", ";", "split_double", "(", "x", ",", "&", "high", ",", "&", "low", ")", ";", "*", "total", "=", "COSTS_N_INSNS", "(", "!", "SMALL_INT", "(", "INTVAL", "(", "high", ")", ")", "+", "!", "SMALL_INT", "(", "INTVAL", "(", "low", ")", ")", ")", ";", "return", "true", ";", "}", "case", "ASHIFT", ":", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "if", "(", "TARGET_SHIFTER", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "CONST_INT", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "16", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "INTVAL", "(", "XEXP", "(", "(", "x", ")", ",", "1", ")", ")", ")", ";", "return", "false", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Compute", "a", "(", "partial", ")", "cost", "for", "rtx", "X", ".", "Return", "true", "if", "the", "complete", "cost", "has", "been", "computed", ",", "and", "false", "if", "subexpressions", "should", "be", "scanned", ".", "In", "either", "case", ",", "*", "TOTAL", "contains", "the", "cost", "result", "." ]

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

[]

[ "<s>", "bool", "aarch_mm_needs_release", "(", "rtx", "const_int", ")", "{", "enum", "memmodel", "model", "=", "memmodel_from_int", "(", "INTVAL", "(", "const_int", ")", ")", ";", "return", "!", "(", "is_mm_relaxed", "(", "model", ")", "||", "is_mm_consume", "(", "model", ")", "||", "is_mm_acquire", "(", "model", ")", ")", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "the", "RTX", "representing", "a", "memory", "model", "is", "a", "memory", "model", "that", "needs", "release", "semantics", "." ]

[ "arm" ]

[]

[ "<s>", "virtual", "MachineInstr", "*", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "MachineInstr", "*", "LoadMI", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "Alpha", "0" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "unsigned", "FIOperandNum", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "isFI", "(", ")", ")", "{", "++", "FIOperandNum", ";", "assert", "(", "FIOperandNum", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BaseReg", ",", "false", ")", ";", "unsigned", "OffsetOperandNo", "=", "getOffsetONFromFION", "(", "MI", ",", "FIOperandNum", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "OffsetOperandNo", ")", ".", "getImm", "(", ")", ";", "MI", ".", "getOperand", "(", "OffsetOperandNo", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MI", ".", "getDesc", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "BaseReg", ",", "TII", ".", "getRegClass", "(", "MCID", ",", "FIOperandNum", ",", "this", ",", "MF", ")", ")", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "PowerPC", "PPC", "0", "\"Instr doesn't have FrameIndex operand!\"" ]

[]

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

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "void", "alpha_emit_xfloating_libcall", "(", "rtx", "func", ",", "rtx", "target", ",", "rtx", "operands", "[", "]", ",", "int", "noperands", ",", "rtx", "equiv", ")", "{", "rtx", "usage", "=", "NULL_RTX", ",", "tmp", ",", "reg", ";", "int", "regno", "=", "16", ",", "i", ";", "start_sequence", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "noperands", ";", "++", "i", ")", "{", "switch", "(", "GET_MODE", "(", "operands", "[", "i", "]", ")", ")", "{", "case", "TFmode", ":", "reg", "=", "gen_rtx_REG", "(", "TFmode", ",", "regno", ")", ";", "regno", "+=", "2", ";", "break", ";", "case", "DFmode", ":", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "regno", "+", "32", ")", ";", "regno", "+=", "1", ";", "break", ";", "case", "VOIDmode", ":", "gcc_assert", "(", "GET_CODE", "(", "operands", "[", "i", "]", ")", "==", "CONST_INT", ")", ";", "case", "DImode", ":", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ";", "regno", "+=", "1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_move_insn", "(", "reg", ",", "operands", "[", "i", "]", ")", ";", "usage", "=", "alloc_EXPR_LIST", "(", "0", ",", "gen_rtx_USE", "(", "VOIDmode", ",", "reg", ")", ",", "usage", ")", ";", "}", "switch", "(", "GET_MODE", "(", "target", ")", ")", "{", "case", "TFmode", ":", "reg", "=", "gen_rtx_REG", "(", "TFmode", ",", "16", ")", ";", "break", ";", "case", "DFmode", ":", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "32", ")", ";", "break", ";", "case", "DImode", ":", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "0", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "tmp", "=", "gen_rtx_MEM", "(", "QImode", ",", "func", ")", ";", "tmp", "=", "emit_call_insn", "(", "GEN_CALL_VALUE", "(", "reg", ",", "tmp", ",", "const0_rtx", ",", "const0_rtx", ",", "const0_rtx", ")", ")", ";", "CALL_INSN_FUNCTION_USAGE", "(", "tmp", ")", "=", "usage", ";", "CONST_OR_PURE_CALL_P", "(", "tmp", ")", "=", "1", ";", "tmp", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_libcall_block", "(", "tmp", ",", "target", ",", "reg", ",", "equiv", ")", ";", "}", "</s>" ]

[ "Emit", "an", "X_floating", "library", "function", "call", ".", "Note", "that", "these", "functions", "do", "not", "follow", "normal", "calling", "conventions", ":", "TFmode", "arguments", "are", "passed", "in", "two", "integer", "registers", "(", "as", "opposed", "to", "indirect", ")", ";", "TFmode", "return", "values", "appear", "in", "R16+R17", ".", "FUNC", "is", "the", "function", "name", "to", "call", ".", "TARGET", "is", "where", "the", "output", "belongs", ".", "OPERANDS", "are", "the", "inputs", ".", "NOPERANDS", "is", "the", "count", "of", "inputs", ".", "EQUIV", "is", "the", "expression", "equivalent", "for", "the", "function", "." ]

[ "alpha", "16", "0", "2", "32", "1", "1", "0", "16", "32", "0", "1" ]

[]

[ "<s>", "bool", "MipsAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "IDVal", "==", "\".dword\"", ")", "{", "parseDataDirective", "(", "8", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".ent\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".end\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".frame\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".set\"", ")", "{", "return", "parseDirectiveSet", "(", ")", ";", "}", "if", "(", "IDVal", "==", "\".fmask\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".mask\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".nan\"", ")", "return", "parseDirectiveNaN", "(", ")", ";", "if", "(", "IDVal", "==", "\".gpword\"", ")", "{", "parseDirectiveGpWord", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".gpdword\"", ")", "{", "parseDirectiveGpDWord", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".word\"", ")", "{", "parseDataDirective", "(", "4", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".option\"", ")", "return", "parseDirectiveOption", "(", ")", ";", "if", "(", "IDVal", "==", "\".abicalls\"", ")", "{", "getTargetStreamer", "(", ")", ".", "emitDirectiveAbiCalls", "(", ")", ";", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "Error", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ",", "\"unexpected token in directive\"", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "}", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".cpsetup\"", ")", "return", "parseDirectiveCPSetup", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\".dword\"", "8", "\".ent\"", "\".end\"", "\".frame\"", "\".set\"", "\".fmask\"", "\".mask\"", "\".nan\"", "\".gpword\"", "\".gpdword\"", "\".word\"", "4", "\".option\"", "\".abicalls\"", "\"unexpected token in directive\"", "\".cpsetup\"" ]

[]

[ "<s>", "static", "tree", "mve_dereference_pointer", "(", "tree", "exp", ",", "tree", "type", ",", "machine_mode", "reg_mode", ",", "machine_mode", "vector_mode", ")", "{", "HOST_WIDE_INT", "reg_size", ",", "vector_size", ",", "nelems", ";", "tree", "elem_type", ",", "upper_bound", ",", "array_type", ";", "vector_size", "=", "GET_MODE_SIZE", "(", "vector_mode", ")", ";", "reg_size", "=", "GET_MODE_SIZE", "(", "reg_mode", ")", ";", "gcc_assert", "(", "POINTER_TYPE_P", "(", "type", ")", ")", ";", "elem_type", "=", "TREE_TYPE", "(", "type", ")", ";", "nelems", "=", "reg_size", "/", "vector_size", ";", "upper_bound", "=", "build_int_cst", "(", "size_type_node", ",", "nelems", "-", "1", ")", ";", "array_type", "=", "build_array_type", "(", "elem_type", ",", "build_index_type", "(", "upper_bound", ")", ")", ";", "return", "fold_build2", "(", "MEM_REF", ",", "array_type", ",", "exp", ",", "build_int_cst", "(", "build_pointer_type", "(", "array_type", ")", ",", "0", ")", ")", ";", "}", "</s>" ]

[ "EXP", "is", "a", "pointer", "argument", "to", "a", "vector", "scatter", "store", "intrinsics", ".", "Consider", "the", "following", "example", ":", "VSTRW", "<", "v", ">", ".", "<", "dt", ">", "Qd", ",", "[", "Qm", "{", ",", "#", "+/-", "<", "imm", ">", "}", "]", "!", "When", "<", "Qm", ">", "used", "as", "the", "base", "register", "for", "the", "target", "address", ",", "this", "function", "is", "used", "to", "derive", "and", "return", "an", "expression", "for", "the", "accessed", "memory", ".", "The", "intrinsic", "function", "operates", "on", "a", "block", "of", "registers", "that", "has", "mode", "REG_MODE", ".", "This", "block", "contains", "vectors", "of", "type", "TYPE_MODE", ".", "The", "function", "references", "the", "memory", "at", "EXP", "of", "type", "TYPE", "and", "in", "mode", "MEM_MODE", ".", "This", "mode", "may", "be", "BLKmode", "if", "no", "more", "suitable", "mode", "is", "available", "." ]

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

[]

[ "<s>", "static", "int", "microblaze_address_insns", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "struct", "microblaze_address_info", "addr", ";", "if", "(", "microblaze_classify_address", "(", "&", "addr", ",", "x", ",", "mode", ",", "false", ")", ")", "{", "switch", "(", "addr", ".", "type", ")", "{", "case", "ADDRESS_REG", ":", "if", "(", "SMALL_INT", "(", "addr", ".", "offset", ")", ")", "return", "1", ";", "else", "return", "2", ";", "case", "ADDRESS_CONST_INT", ":", "if", "(", "SMALL_INT", "(", "x", ")", ")", "return", "1", ";", "else", "return", "2", ";", "case", "ADDRESS_REG_INDEX", ":", "return", "1", ";", "case", "ADDRESS_SYMBOLIC", ":", "case", "ADDRESS_GOTOFF", ":", "return", "2", ";", "case", "ADDRESS_TLS", ":", "switch", "(", "addr", ".", "tls_type", ")", "{", "case", "TLS_GD", ":", "return", "2", ";", "case", "TLS_LDM", ":", "return", "2", ";", "case", "TLS_DTPREL", ":", "return", "1", ";", "default", ":", "abort", "(", ")", ";", "}", "default", ":", "break", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "needed", "to", "load", "or", "store", "a", "value", "of", "mode", "MODE", "at", "X", ".", "Return", "0", "if", "X", "is", "n't", "valid", "for", "MODE", "." ]

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

[]

[ "<s>", "static", "unsigned", "getLinkageSize", "(", "bool", "LP64", ",", "bool", "isMacho", ")", "{", "if", "(", "isMacho", ")", "return", "6", "*", "(", "LP64", "?", "8", ":", "4", ")", ";", "return", "8", ";", "}", "</s>" ]

[ "getLinkageSize", "-", "Return", "the", "size", "of", "the", "PowerPC", "ABI", "linkage", "area", "." ]

[ "PowerPC", "6", "8", "4", "8" ]

[]

[ "<s>", "void", "arc_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "register", "rtx", "base", ",", "index", "=", "0", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fputs", "(", "reg_names", "[", "REGNO", "(", "addr", ")", "]", ",", "file", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "if", "(", "SYMBOL_REF_SMALL_P", "(", "addr", ")", ")", "fprintf", "(", "file", ",", "\"@sda\"", ")", ";", "break", ";", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "MULT", ")", "index", "=", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "index", "=", "XEXP", "(", "addr", ",", "0", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ",", "index", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "gcc_assert", "(", "OBJECT_P", "(", "base", ")", ")", ";", "arc_print_operand_address", "(", "file", ",", "base", ")", ";", "if", "(", "CONSTANT_P", "(", "base", ")", "&&", "CONST_INT_P", "(", "index", ")", ")", "fputc", "(", "'+'", ",", "file", ")", ";", "else", "fputc", "(", "','", ",", "file", ")", ";", "gcc_assert", "(", "OBJECT_P", "(", "index", ")", ")", ";", "arc_print_operand_address", "(", "file", ",", "index", ")", ";", "break", ";", "case", "CONST", ":", "{", "rtx", "c", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "c", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "c", ",", "1", ")", ")", "==", "CONST_INT", ")", ";", "output_address", "(", "VOIDmode", ",", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "break", ";", "}", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "default", ":", "if", "(", "flag_pic", ")", "arc_output_pic_addr_const", "(", "file", ",", "addr", ",", "0", ")", ";", "else", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Print", "a", "memory", "address", "as", "an", "operand", "to", "reference", "that", "memory", "location", "." ]

[ "arc", "0", "\"@sda\"", "0", "0", "0", "1", "0", "0", "1", "0", "1", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "&", "SrcReg", ",", "Register", "&", "SrcReg2", ",", "int64_t", "&", "CmpMask", ",", "int64_t", "&", "CmpValue", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "CMPri", ":", "case", "ARM", "::", "t2CMPri", ":", "case", "ARM", "::", "tCMPi8", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "case", "ARM", "::", "CMPrr", ":", "case", "ARM", "::", "t2CMPrr", ":", "case", "ARM", "::", "tCMPr", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "ARM", "::", "TSTri", ":", "case", "ARM", "::", "t2TSTri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "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", "." ]

[ "ARM", "ARM", "ARM::CMPri", "ARM::t2CMPri", "ARM::tCMPi8", "0", "0", "0", "1", "ARM::CMPrr", "ARM::t2CMPrr", "ARM::tCMPr", "0", "1", "0", "0", "ARM::TSTri", "ARM::t2TSTri", "0", "0", "1", "0" ]

[]

[ "<s>", "bool", "SIFoldOperands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "!", "isSafeToFold", "(", "MI", ")", ")", "continue", ";", "MachineOperand", "&", "OpToFold", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "bool", "FoldingImm", "=", "OpToFold", ".", "isImm", "(", ")", "||", "OpToFold", ".", "isFI", "(", ")", ";", "if", "(", "!", "FoldingImm", "&&", "!", "OpToFold", ".", "isReg", "(", ")", ")", "continue", ";", "if", "(", "OpToFold", ".", "isReg", "(", ")", "&&", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "OpToFold", ".", "getReg", "(", ")", ")", ")", "continue", ";", "MachineOperand", "&", "Dst", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Dst", ".", "isReg", "(", ")", "&&", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Dst", ".", "getReg", "(", ")", ")", ")", "continue", ";", "foldInstOperand", "(", "MI", ",", "OpToFold", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "RegisterRef", "PhysicalRegisterInfo", "::", "normalize", "(", "RegisterRef", "RR", ")", "const", "{", "return", "RR", ";", "}", "</s>" ]

[ "Weight", "normalization", "function", "." ]

[ "Hexagon" ]

[]

[ "<s>", "int", "mn10300_get_live_callee_saved_regs", "(", ")", "{", "int", "mask", ";", "int", "i", ";", "mask", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "regs_ever_live", "[", "i", "]", "&&", "!", "call_used_regs", "[", "i", "]", ")", "mask", "|=", "(", "1", "<<", "i", ")", ";", "if", "(", "(", "mask", "&", "0x3c000", ")", "!=", "0", ")", "mask", "|=", "0x3c000", ";", "return", "mask", ";", "}", "</s>" ]

[ "Returns", "the", "set", "of", "live", ",", "callee-saved", "registers", "as", "a", "bitmask", ".", "The", "callee-saved", "extended", "registers", "can", "not", "be", "stored", "individually", ",", "so", "all", "of", "them", "will", "be", "included", "in", "the", "mask", "if", "any", "one", "of", "them", "is", "used", "." ]

[ "mn10300", "0", "0", "1", "0x3c000", "0", "0x3c000" ]

[]

[ "<s>", "void", "CSKYDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "SDLoc", "Dl", "(", "N", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", ";", "bool", "IsSelected", "=", "false", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "}", "if", "(", "IsSelected", ")", "return", ";", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "\"== \"", "\"\\n\"", "1" ]

[]

[ "<s>", "static", "void", "nios2_init_builtins", "(", "void", ")", "{", "unsigned", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "nios2_builtins", ")", ";", "i", "++", ")", "{", "const", "struct", "nios2_builtin_desc", "*", "d", "=", "&", "nios2_builtins", "[", "i", "]", ";", "tree", "fndecl", "=", "add_builtin_function", "(", "d", "->", "name", ",", "nios2_ftype", "(", "d", "->", "ftype", ")", ",", "i", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL", ")", ";", "nios2_register_builtin_fndecl", "(", "i", ",", "fndecl", ")", ";", "}", "nios2_fpu_builtin_base", "=", "ARRAY_SIZE", "(", "nios2_builtins", ")", ";", "nios2_init_fpu_builtins", "(", "nios2_fpu_builtin_base", ")", ";", "nios2_custom_builtin_base", "=", "nios2_fpu_builtin_base", "+", "ARRAY_SIZE", "(", "nios2_fpu_insn", ")", ";", "nios2_custom_builtin_end", "=", "nios2_custom_builtin_base", "+", "NUM_CUSTOM_BUILTINS", ";", "nios2_init_custom_builtins", "(", "nios2_custom_builtin_base", ")", ";", "}", "</s>" ]

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

[ "nios2", "0" ]

[]

[ "<s>", "void", "aarch64_split_atomic_op", "(", "enum", "rtx_code", "code", ",", "rtx", "old_out", ",", "rtx", "new_out", ",", "rtx", "mem", ",", "rtx", "value", ",", "rtx", "model_rtx", ",", "rtx", "cond", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "machine_mode", "wmode", "=", "(", "mode", "==", "DImode", "?", "DImode", ":", "SImode", ")", ";", "const", "enum", "memmodel", "model", "=", "memmodel_from_int", "(", "INTVAL", "(", "model_rtx", ")", ")", ";", "const", "bool", "is_sync", "=", "is_mm_sync", "(", "model", ")", ";", "rtx_code_label", "*", "label", ";", "rtx", "x", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "if", "(", "new_out", ")", "new_out", "=", "gen_lowpart", "(", "wmode", ",", "new_out", ")", ";", "if", "(", "old_out", ")", "old_out", "=", "gen_lowpart", "(", "wmode", ",", "old_out", ")", ";", "else", "old_out", "=", "new_out", ";", "value", "=", "simplify_gen_subreg", "(", "wmode", ",", "value", ",", "mode", ",", "0", ")", ";", "if", "(", "is_sync", ")", "aarch64_emit_load_exclusive", "(", "mode", ",", "old_out", ",", "mem", ",", "GEN_INT", "(", "MEMMODEL_RELAXED", ")", ")", ";", "else", "aarch64_emit_load_exclusive", "(", "mode", ",", "old_out", ",", "mem", ",", "model_rtx", ")", ";", "switch", "(", "code", ")", "{", "case", "SET", ":", "new_out", "=", "value", ";", "break", ";", "case", "NOT", ":", "x", "=", "gen_rtx_AND", "(", "wmode", ",", "old_out", ",", "value", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "new_out", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_NOT", "(", "wmode", ",", "new_out", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "new_out", ",", "x", ")", ")", ";", "break", ";", "case", "MINUS", ":", "if", "(", "CONST_INT_P", "(", "value", ")", ")", "{", "value", "=", "GEN_INT", "(", "-", "INTVAL", "(", "value", ")", ")", ";", "code", "=", "PLUS", ";", "}", "default", ":", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "wmode", ",", "old_out", ",", "value", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "new_out", ",", "x", ")", ")", ";", "break", ";", "}", "aarch64_emit_store_exclusive", "(", "mode", ",", "cond", ",", "mem", ",", "gen_lowpart", "(", "mode", ",", "new_out", ")", ",", "model_rtx", ")", ";", "if", "(", "aarch64_track_speculation", ")", "{", "rtx", "cc_reg", "=", "aarch64_gen_compare_reg", "(", "NE", ",", "cond", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_NE", "(", "GET_MODE", "(", "cc_reg", ")", ",", "cc_reg", ",", "const0_rtx", ")", ";", "}", "else", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label", ")", ",", "pc_rtx", ")", ";", "aarch64_emit_unlikely_jump", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "if", "(", "is_sync", ")", "aarch64_emit_post_barrier", "(", "model", ")", ";", "}", "</s>" ]

[ "Split", "an", "atomic", "operation", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "void", "ARMElfTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "isAAPCS_ABI", "=", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isAAPCS_ABI", "(", ")", ";", "if", "(", "isAAPCS_ABI", ")", "{", "StaticCtorSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".init_array\"", ",", "ELF", "::", "SHT_INIT_ARRAY", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "StaticDtorSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".fini_array\"", ",", "ELF", "::", "SHT_FINI_ARRAY", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "LSDASection", "=", "NULL", ";", "}", "AttributesSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".ARM.attributes\"", ",", "ELF", "::", "SHT_ARM_ATTRIBUTES", ",", "0", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "ARM", "ARM", "ARM", "\".init_array\"", "\".fini_array\"", "\".ARM.attributes\"", "ARM", "0" ]

[]

[ "<s>", "static", "int", "ix86_function_regparm", "(", "tree", "type", ",", "tree", "decl", ")", "{", "tree", "attr", ";", "int", "regparm", "=", "ix86_regparm", ";", "bool", "user_convention", "=", "false", ";", "if", "(", "!", "TARGET_64BIT", ")", "{", "attr", "=", "lookup_attribute", "(", "\"regparm\"", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ";", "if", "(", "attr", ")", "{", "regparm", "=", "TREE_INT_CST_LOW", "(", "TREE_VALUE", "(", "TREE_VALUE", "(", "attr", ")", ")", ")", ";", "user_convention", "=", "true", ";", "}", "if", "(", "lookup_attribute", "(", "\"fastcall\"", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ")", "{", "regparm", "=", "2", ";", "user_convention", "=", "true", ";", "}", "if", "(", "!", "TARGET_64BIT", "&&", "!", "user_convention", "&&", "decl", "&&", "flag_unit_at_a_time", "&&", "!", "profile_flag", ")", "{", "struct", "cgraph_local_info", "*", "i", "=", "cgraph_local_info", "(", "decl", ")", ";", "if", "(", "i", "&&", "i", "->", "local", ")", "{", "int", "local_regparm", ",", "globals", "=", "0", ",", "regno", ";", "for", "(", "local_regparm", "=", "0", ";", "local_regparm", "<", "3", ";", "local_regparm", "++", ")", "if", "(", "global_regs", "[", "local_regparm", "]", ")", "break", ";", "if", "(", "local_regparm", "==", "3", "&&", "decl_function_context", "(", "decl", ")", "&&", "!", "DECL_NO_STATIC_CHAIN", "(", "decl", ")", ")", "local_regparm", "=", "2", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "6", ";", "regno", "++", ")", "if", "(", "global_regs", "[", "regno", "]", ")", "globals", "++", ";", "local_regparm", "=", "globals", "<", "local_regparm", "?", "local_regparm", "-", "globals", ":", "0", ";", "if", "(", "local_regparm", ">", "regparm", ")", "regparm", "=", "local_regparm", ";", "}", "}", "}", "return", "regparm", ";", "}", "</s>" ]

[ "Return", "the", "regparm", "value", "for", "a", "function", "with", "the", "indicated", "TYPE", "and", "DECL", ".", "DECL", "may", "be", "NULL", "when", "calling", "function", "indirectly", "or", "considering", "a", "libcall", "." ]

[ "i386", "\"regparm\"", "\"fastcall\"", "2", "0", "0", "3", "3", "2", "0", "6", "0" ]

[]

[ "<s>", "static", "bool", "arm_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "size", "==", "UNITS_PER_WORD", "&&", "aligned_p", ")", "{", "fputs", "(", "\"\\t.word\\t\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "if", "(", "NEED_GOT_RELOC", "&&", "flag_pic", "&&", "making_const_table", "&&", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "(", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", "||", "SYMBOL_REF_LOCAL_P", "(", "x", ")", ")", ")", "fputs", "(", "\"(GOTOFF)\"", ",", "asm_out_file", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "fputs", "(", "\"(GOTOFF)\"", ",", "asm_out_file", ")", ";", "else", "fputs", "(", "\"(GOT)\"", ",", "asm_out_file", ")", ";", "}", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "if", "(", "arm_vector_mode_supported_p", "(", "GET_MODE", "(", "x", ")", ")", ")", "{", "int", "i", ",", "units", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", ";", "units", "=", "CONST_VECTOR_NUNITS", "(", "x", ")", ";", "switch", "(", "GET_MODE", "(", "x", ")", ")", "{", "case", "V2SImode", ":", "size", "=", "4", ";", "break", ";", "case", "V4HImode", ":", "size", "=", "2", ";", "break", ";", "case", "V8QImode", ":", "size", "=", "1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "units", ";", "i", "++", ")", "{", "rtx", "elt", ";", "elt", "=", "CONST_VECTOR_ELT", "(", "x", ",", "i", ")", ";", "assemble_integer", "(", "elt", ",", "size", ",", "i", "==", "0", "?", "BIGGEST_ALIGNMENT", ":", "size", "*", "BITS_PER_UNIT", ",", "1", ")", ";", "}", "return", "true", ";", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>" ]

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

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

[]

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

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

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "void", "SystemZPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createSystemZPostRewritePass", "(", "getSystemZTargetMachine", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "." ]

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

[]

[ "<s>", "unsigned", "X86FrameLowering", "::", "getWinEHFuncletFrameSize", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "unsigned", "CSSize", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getCalleeSavedFrameSize", "(", ")", ";", "unsigned", "UsedSize", ";", "EHPersonality", "Personality", "=", "classifyEHPersonality", "(", "MF", ".", "getFunction", "(", ")", "->", "getPersonalityFn", "(", ")", ")", ";", "if", "(", "Personality", "==", "EHPersonality", "::", "CoreCLR", ")", "{", "UsedSize", "=", "getPSPSlotOffsetFromSP", "(", "MF", ")", "+", "SlotSize", ";", "}", "else", "{", "UsedSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getMaxCallFrameSize", "(", ")", ";", "}", "unsigned", "FrameSizeMinusRBP", "=", "alignTo", "(", "CSSize", "+", "UsedSize", ",", "getStackAlignment", "(", ")", ")", ";", "return", "FrameSizeMinusRBP", "-", "CSSize", ";", "}", "</s>" ]

[ "Funclets", "only", "need", "to", "account", "for", "space", "for", "the", "callee", "saved", "registers", ",", "as", "the", "locals", "are", "accounted", "for", "in", "the", "parent", "'s", "stack", "frame", "." ]

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

[]

[ "<s>", "const", "FPGASubtarget", "*", "FPGATargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "FPGAAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "StringRef", "FPGA", "=", "!", "FPGAAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FPGAAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetCPU", ";", "StringRef", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetFS", ";", "SmallString", "<", "512", ">", "Key", ";", "Key", ".", "reserve", "(", "FPGA", ".", "size", "(", ")", "+", "FS", ".", "size", "(", ")", ")", ";", "Key", "+=", "FPGA", ";", "Key", "+=", "FS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "FPGASubtarget", ">", "(", "TargetTriple", ",", "FPGA", ",", "FS", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "FPGA", "FPGA", "FPGA", "FPGA", "\"target-cpu\"", "\"target-features\"", "FPGA", "FPGA", "FPGA", "512", "FPGA", "FPGA", "FPGA", "FPGA" ]

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RetLocs", ";", "CCState", "RetCCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RetLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "RetCCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_SystemZ", ")", ";", "if", "(", "RetLocs", ".", "empty", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "SystemZISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "SDValue", "Glue", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", ";", "RetOps", ".", "push_back", "(", "Chain", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "RetLocs", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "CCValAssign", "&", "VA", "=", "RetLocs", "[", "I", "]", ";", "SDValue", "RetValue", "=", "OutVals", "[", "I", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "RetValue", "=", "convertValVTToLocVT", "(", "DAG", ",", "DL", ",", "VA", ",", "RetValue", ")", ";", "unsigned", "Reg", "=", "VA", ".", "getLocReg", "(", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "RetValue", ",", "Glue", ")", ";", "Glue", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "Reg", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Glue", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Glue", ")", ";", "return", "DAG", ".", "getNode", "(", "SystemZISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "ISD::OutputArg", "16", "SystemZ", "SystemZISD::RET_FLAG", "MVT::Other", "4", "0", "\"Can only return in registers!\"", "1", "0", "SystemZISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "void", "HexagonCommonGEP", "::", "removeDeadCode", "(", ")", "{", "ValueVect", "BO", ";", "BO", ".", "push_back", "(", "&", "Fn", "->", "front", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "BO", ".", "size", "(", ")", ";", "++", "i", ")", "{", "BasicBlock", "*", "B", "=", "cast", "<", "BasicBlock", ">", "(", "BO", "[", "i", "]", ")", ";", "DomTreeNode", "*", "N", "=", "DT", "->", "getNode", "(", "B", ")", ";", "typedef", "GraphTraits", "<", "DomTreeNode", "*", ">", "GTN", ";", "typedef", "GTN", "::", "ChildIteratorType", "Iter", ";", "for", "(", "Iter", "I", "=", "GTN", "::", "child_begin", "(", "N", ")", ",", "E", "=", "GTN", "::", "child_end", "(", "N", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "BO", ".", "push_back", "(", "(", "*", "I", ")", "->", "getBlock", "(", ")", ")", ";", "}", "for", "(", "unsigned", "i", "=", "BO", ".", "size", "(", ")", ";", "i", ">", "0", ";", "--", "i", ")", "{", "BasicBlock", "*", "B", "=", "cast", "<", "BasicBlock", ">", "(", "BO", "[", "i", "-", "1", "]", ")", ";", "BasicBlock", "::", "InstListType", "&", "IL", "=", "B", "->", "getInstList", "(", ")", ";", "typedef", "BasicBlock", "::", "InstListType", "::", "reverse_iterator", "reverse_iterator", ";", "ValueVect", "Ins", ";", "for", "(", "reverse_iterator", "I", "=", "IL", ".", "rbegin", "(", ")", ",", "E", "=", "IL", ".", "rend", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Ins", ".", "push_back", "(", "&", "*", "I", ")", ";", "for", "(", "ValueVect", "::", "iterator", "I", "=", "Ins", ".", "begin", "(", ")", ",", "E", "=", "Ins", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Instruction", "*", "In", "=", "cast", "<", "Instruction", ">", "(", "*", "I", ")", ";", "if", "(", "isInstructionTriviallyDead", "(", "In", ")", ")", "In", "->", "eraseFromParent", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "Remove", "all", "dead", "instructions", "between", "the", "I", "and", "E", "." ]

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

[]

[ "<s>", "static", "rtx", "conditionalize_nonjump", "(", "rtx", "pat", ",", "rtx", "cond", ",", "rtx", "insn", ",", "bool", "annulled", ")", "{", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", "{", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "if", "(", "COMMUTATIVE_P", "(", "src", ")", ")", "{", "rtx", "src0", "=", "XEXP", "(", "src", ",", "0", ")", ";", "rtx", "src1", "=", "XEXP", "(", "src", ",", "1", ")", ";", "rtx", "dst", "=", "SET_DEST", "(", "pat", ")", ";", "if", "(", "rtx_equal_p", "(", "src1", ",", "dst", ")", "&&", "!", "rtx_equal_p", "(", "src0", ",", "dst", ")", "&&", "REG_P", "(", "src0", ")", ")", "pat", "=", "gen_rtx_SET", "(", "dst", ",", "gen_rtx_fmt_ee", "(", "GET_CODE", "(", "src", ")", ",", "GET_MODE", "(", "src", ")", ",", "src1", ",", "src0", ")", ")", ";", "}", "}", "if", "(", "RTX_FRAME_RELATED_P", "(", "insn", ")", ")", "{", "gcc_assert", "(", "annulled", ")", ";", "rtx", "note", "=", "alloc_reg_note", "(", "REG_FRAME_RELATED_EXPR", ",", "pat", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "validate_change", "(", "insn", ",", "&", "REG_NOTES", "(", "insn", ")", ",", "note", ",", "1", ")", ";", "}", "pat", "=", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "cond", ",", "pat", ")", ";", "return", "pat", ";", "}", "</s>" ]

[ "Return", "version", "of", "PAT", "conditionalized", "with", "COND", ",", "which", "is", "part", "of", "INSN", ".", "ANNULLED", "indicates", "if", "INSN", "is", "an", "annulled", "delay-slot", "insn", ".", "Register", "further", "changes", "if", "necessary", "." ]

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

[]

[ "<s>", "static", "void", "emitSPUpdate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "int64_t", "NumBytes", ",", "const", "TargetInstrInfo", "&", "TII", ")", "{", "unsigned", "Opc", ";", "uint64_t", "Chunk", ";", "bool", "isSub", "=", "NumBytes", "<", "0", ";", "uint64_t", "Offset", "=", "isSub", "?", "-", "NumBytes", ":", "NumBytes", ";", "if", "(", "Offset", ">=", "(", "1LL", "<<", "15", ")", "-", "1", ")", "{", "Opc", "=", "SystemZ", "::", "ADD64ri32", ";", "Chunk", "=", "(", "1LL", "<<", "31", ")", "-", "1", ";", "}", "else", "{", "Opc", "=", "SystemZ", "::", "ADD64ri16", ";", "Chunk", "=", "(", "1LL", "<<", "15", ")", "-", "1", ";", "}", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "while", "(", "Offset", ")", "{", "uint64_t", "ThisVal", "=", "(", "Offset", ">", "Chunk", ")", "?", "Chunk", ":", "Offset", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "SystemZ", "::", "R15D", ")", ".", "addReg", "(", "SystemZ", "::", "R15D", ")", ".", "addImm", "(", "isSub", "?", "-", "ThisVal", ":", "ThisVal", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "Offset", "-=", "ThisVal", ";", "}", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "increment", "/", "decrement", "the", "stack", "pointer", "by", "a", "constant", "value", "." ]

[ "SystemZ", "0", "1LL", "15", "1", "SystemZ::ADD64ri32", "1LL", "31", "1", "SystemZ::ADD64ri16", "1LL", "15", "1", "SystemZ::R15D", "SystemZ::R15D", "3" ]

[]

[ "<s>", "Instruction", "*", "PPCTargetLowering", "::", "emitLeadingFence", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Instruction", "*", "Inst", ",", "AtomicOrdering", "Ord", ")", "const", "{", "if", "(", "Ord", "==", "AtomicOrdering", "::", "SequentiallyConsistent", ")", "return", "callIntrinsic", "(", "Builder", ",", "Intrinsic", "::", "ppc_sync", ")", ";", "if", "(", "isReleaseOrStronger", "(", "Ord", ")", ")", "return", "callIntrinsic", "(", "Builder", ",", "Intrinsic", "::", "ppc_lwsync", ")", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "Custom", "Lower", "{", "." ]

[ "PowerPC", "PPC", "Intrinsic::ppc_sync", "Intrinsic::ppc_lwsync" ]

[]

[ "<s>", "static", "bool", "mt_pass_in_stack", "(", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "tree", "type", ")", "{", "return", "(", "(", "(", "type", ")", "!=", "0", "&&", "(", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "!=", "INTEGER_CST", "||", "TREE_ADDRESSABLE", "(", "type", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MUST_PASS_IN_STACK", "hook", "." ]

[ "mt", "0" ]

[]

[ "<s>", "static", "int", "rid_int128", "(", "void", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NUM_INT_N_ENTS", ";", "i", "++", ")", "if", "(", "int_n_enabled_p", "[", "i", "]", "&&", "int_n_data", "[", "i", "]", ".", "bitsize", "==", "128", ")", "return", "RID_INT_N_0", "+", "i", ";", "return", "RID_MAX", "+", "1", ";", "}", "</s>" ]

[ "Helper", "function", "to", "find", "out", "which", "RID_INT_N_", "*", "code", "is", "the", "one", "for", "__int128", ",", "if", "any", ".", "Returns", "RID_MAX+1", "if", "none", "apply", ",", "which", "is", "safe", "(", "for", "our", "purposes", ",", "since", "we", "always", "expect", "to", "have", "__int128", ")", "to", "compare", "against", "." ]

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

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "assert", "(", "!", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", "&&", "\"No stack realignment on AArch64!\"", ")", ";", "return", "(", "MFI", "->", "hasCalls", "(", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"No stack realignment on AArch64!\"" ]

[]

[ "<s>", "static", "rtx", "arc_dwarf_register_span", "(", "rtx", "rtl", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "rtl", ")", ";", "unsigned", "regno", ";", "rtx", "p", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "!=", "8", ")", "return", "NULL_RTX", ";", "p", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "2", ")", ")", ";", "regno", "=", "REGNO", "(", "rtl", ")", ";", "XVECEXP", "(", "p", ",", "0", ",", "0", ")", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "XVECEXP", "(", "p", ",", "0", ",", "1", ")", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "1", ")", ";", "return", "p", ";", "}", "</s>" ]

[ "Return", "a", "parallel", "of", "registers", "to", "represent", "where", "to", "find", "the", "register", "pieces", "if", "required", ",", "otherwise", "NULL_RTX", "." ]

[ "arc", "8", "2", "0", "0", "0", "1", "1" ]

[]

[ "<s>", "rtx", "mmix_gen_compare_reg", "(", "RTX_CODE", "code", ",", "rtx", "x", ",", "rtx", "y", ")", "{", "enum", "machine_mode", "ccmode", "=", "SELECT_CC_MODE", "(", "code", ",", "x", ",", "y", ")", ";", "rtx", "cc_reg", ";", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", "==", "VOIDmode", "?", "GET_MODE", "(", "y", ")", ":", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_FLOAT", "?", "DFmode", ":", "DImode", ";", "if", "(", "!", "mmix_valid_comparison", "(", "code", ",", "mode", ",", "x", ")", ")", "return", "NULL_RTX", ";", "cc_reg", "=", "gen_reg_rtx", "(", "ccmode", ")", ";", "if", "(", "!", "REG_P", "(", "x", ")", "&&", "!", "REG_P", "(", "y", ")", ")", "x", "=", "force_reg", "(", "mode", ",", "x", ")", ";", "if", "(", "!", "REG_P", "(", "y", ")", "&&", "(", "GET_CODE", "(", "y", ")", "!=", "CONST_INT", "||", "!", "CONST_OK_FOR_LETTER_P", "(", "INTVAL", "(", "y", ")", ",", "'I'", ")", ")", ")", "y", "=", "force_reg", "(", "mode", ",", "y", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cc_reg", ",", "gen_rtx_COMPARE", "(", "ccmode", ",", "x", ",", "y", ")", ")", ")", ";", "return", "cc_reg", ";", "}", "</s>" ]

[ "X", "and", "Y", "are", "two", "things", "to", "compare", "using", "CODE", ".", "Emit", "a", "compare", "insn", "if", "possible", "and", "return", "the", "rtx", "for", "the", "cc-reg", "in", "the", "proper", "mode", ",", "or", "NULL_RTX", "if", "this", "is", "not", "a", "valid", "comparison", "." ]

[ "mmix" ]

[]

[ "<s>", "void", "arc_expand_epilogue", "(", "int", "sibcall_p", ")", "{", "int", "size", ";", "unsigned", "int", "fn_type", "=", "arc_compute_function_type", "(", "cfun", ")", ";", "unsigned", "int", "size_to_deallocate", ";", "int", "restored", ";", "int", "can_trust_sp_p", "=", "!", "cfun", "->", "calls_alloca", ";", "int", "first_offset", ";", "bool", "restore_fp", "=", "arc_frame_pointer_needed", "(", ")", "&&", "!", "ARC_AUTOFP_IRQ_P", "(", "fn_type", ")", ";", "bool", "restore_blink", "=", "arc_must_save_return_addr", "(", "cfun", ")", "&&", "!", "ARC_AUTOBLINK_IRQ_P", "(", "fn_type", ")", ";", "unsigned", "int", "gmask", "=", "cfun", "->", "machine", "->", "frame_info", ".", "gmask", ";", "bool", "return_p", "=", "!", "sibcall_p", "&&", "fn_type", "==", "ARC_FUNCTION_NORMAL", "&&", "!", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", ";", "struct", "arc_frame_info", "*", "frame", "=", "&", "cfun", "->", "machine", "->", "frame_info", ";", "if", "(", "ARC_NAKED_P", "(", "fn_type", ")", ")", "return", ";", "size", "=", "arc_compute_frame_size", "(", ")", ";", "size_to_deallocate", "=", "size", ";", "first_offset", "=", "size", "-", "(", "frame", "->", "pretend_size", "+", "frame", "->", "reg_size", "+", "frame", "->", "extra_size", ")", ";", "if", "(", "!", "can_trust_sp_p", ")", "gcc_assert", "(", "arc_frame_pointer_needed", "(", ")", ")", ";", "if", "(", "size", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "if", "(", "TARGET_CODE_DENSITY", "&&", "TARGET_CODE_DENSITY_FRAME", "&&", "!", "ARC_AUTOFP_IRQ_P", "(", "fn_type", ")", "&&", "!", "ARC_AUTOBLINK_IRQ_P", "(", "fn_type", ")", "&&", "!", "ARC_INTERRUPT_P", "(", "fn_type", ")", "&&", "arc_enter_leave_p", "(", "gmask", ")", ")", "{", "size_to_deallocate", "-=", "arc_restore_callee_leave", "(", "gmask", ",", "restore_blink", ",", "restore_fp", ",", "return_p", ",", "first_offset", ")", ";", "if", "(", "return_p", ")", "{", "gcc_assert", "(", "size_to_deallocate", "==", "0", ")", ";", "return", ";", "}", "}", "else", "if", "(", "frame", "->", "millicode_end_reg", ">", "14", ")", "{", "size_to_deallocate", "-=", "arc_restore_callee_milli", "(", "gmask", ",", "restore_blink", ",", "restore_fp", ",", "return_p", ",", "first_offset", ")", ";", "if", "(", "return_p", ")", "{", "gcc_assert", "(", "size_to_deallocate", "==", "0", ")", ";", "return", ";", "}", "}", "else", "size_to_deallocate", "-=", "arc_restore_callee_saves", "(", "gmask", ",", "restore_blink", ",", "restore_fp", ",", "first_offset", ",", "size_to_deallocate", ")", ";", "restored", "=", "size", "-", "size_to_deallocate", ";", "if", "(", "size", ">", "restored", ")", "frame_stack_add", "(", "size", "-", "restored", ")", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "emit_insn", "(", "gen_add2_insn", "(", "stack_pointer_rtx", ",", "EH_RETURN_STACKADJ_RTX", ")", ")", ";", "if", "(", "sibcall_p", "==", "FALSE", ")", "emit_jump_insn", "(", "gen_simple_return", "(", ")", ")", ";", "}", "</s>" ]

[ "Do", "any", "necessary", "cleanup", "after", "a", "function", "to", "restore", "stack", ",", "frame", ",", "and", "regs", "." ]

[ "arc", "0", "14", "0" ]

[]

[ "<s>", "void", "reset", "(", ")", "override", "{", "MappingSymbolCounter", "=", "0", ";", "MCELFStreamer", "::", "reset", "(", ")", ";", "LastMappingSymbols", ".", "clear", "(", ")", ";", "LastEMS", "=", "EMS_None", ";", "}", "</s>" ]

[ "Reset", "an", "existing", "scalar", "value", "for", "Def", "and", "a", "given", "Instance", "." ]

[ "AArch64", "0" ]

[]

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

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

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

[]

[ "<s>", "unsigned", "HexagonTTIImpl", "::", "getIntrinsicInstrCost", "(", "const", "IntrinsicCostAttributes", "&", "ICA", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "if", "(", "ICA", ".", "getID", "(", ")", "==", "Intrinsic", "::", "bswap", ")", "{", "std", "::", "pair", "<", "int", ",", "MVT", ">", "LT", "=", "TLI", ".", "getTypeLegalizationCost", "(", "DL", ",", "ICA", ".", "getReturnType", "(", ")", ")", ";", "return", "LT", ".", "first", "+", "2", ";", "}", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ICA", ",", "CostKind", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Intrinsic::bswap", "2" ]

[]

[ "<s>", "static", "int", "function_arg_advance_32", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "HOST_WIDE_INT", "bytes", ",", "HOST_WIDE_INT", "words", ")", "{", "int", "res", "=", "0", ";", "bool", "error_p", "=", "false", ";", "if", "(", "TARGET_IAMCU", ")", "{", "if", "(", "!", "VECTOR_MODE_P", "(", "mode", ")", "&&", "bytes", "<=", "8", ")", "goto", "pass_in_reg", ";", "return", "res", ";", "}", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "E_BLKmode", ":", "if", "(", "bytes", "<", "0", ")", "break", ";", "case", "E_DImode", ":", "case", "E_SImode", ":", "case", "E_HImode", ":", "case", "E_QImode", ":", "pass_in_reg", ":", "cum", "->", "words", "+=", "words", ";", "cum", "->", "nregs", "-=", "words", ";", "cum", "->", "regno", "+=", "words", ";", "if", "(", "cum", "->", "nregs", ">=", "0", ")", "res", "=", "words", ";", "if", "(", "cum", "->", "nregs", "<=", "0", ")", "{", "cum", "->", "nregs", "=", "0", ";", "cfun", "->", "machine", "->", "arg_reg_available", "=", "false", ";", "cum", "->", "regno", "=", "0", ";", "}", "break", ";", "case", "E_OImode", ":", "gcc_unreachable", "(", ")", ";", "case", "E_DFmode", ":", "if", "(", "cum", "->", "float_in_sse", "==", "-", "1", ")", "error_p", "=", "true", ";", "if", "(", "cum", "->", "float_in_sse", "<", "2", ")", "break", ";", "case", "E_SFmode", ":", "if", "(", "cum", "->", "float_in_sse", "==", "-", "1", ")", "error_p", "=", "true", ";", "if", "(", "cum", "->", "float_in_sse", "<", "1", ")", "break", ";", "case", "E_V16HFmode", ":", "case", "E_V16BFmode", ":", "case", "E_V8SFmode", ":", "case", "E_V8SImode", ":", "case", "E_V64QImode", ":", "case", "E_V32HImode", ":", "case", "E_V16SImode", ":", "case", "E_V8DImode", ":", "case", "E_V32HFmode", ":", "case", "E_V32BFmode", ":", "case", "E_V16SFmode", ":", "case", "E_V8DFmode", ":", "case", "E_V32QImode", ":", "case", "E_V16HImode", ":", "case", "E_V4DFmode", ":", "case", "E_V4DImode", ":", "case", "E_TImode", ":", "case", "E_V16QImode", ":", "case", "E_V8HImode", ":", "case", "E_V4SImode", ":", "case", "E_V2DImode", ":", "case", "E_V8HFmode", ":", "case", "E_V8BFmode", ":", "case", "E_V4SFmode", ":", "case", "E_V2DFmode", ":", "if", "(", "!", "type", "||", "!", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "cum", "->", "sse_words", "+=", "words", ";", "cum", "->", "sse_nregs", "-=", "1", ";", "cum", "->", "sse_regno", "+=", "1", ";", "if", "(", "cum", "->", "sse_nregs", "<=", "0", ")", "{", "cum", "->", "sse_nregs", "=", "0", ";", "cum", "->", "sse_regno", "=", "0", ";", "}", "}", "break", ";", "case", "E_V8QImode", ":", "case", "E_V4HImode", ":", "case", "E_V4HFmode", ":", "case", "E_V4BFmode", ":", "case", "E_V2SImode", ":", "case", "E_V2SFmode", ":", "case", "E_V1TImode", ":", "case", "E_V1DImode", ":", "if", "(", "!", "type", "||", "!", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "cum", "->", "mmx_words", "+=", "words", ";", "cum", "->", "mmx_nregs", "-=", "1", ";", "cum", "->", "mmx_regno", "+=", "1", ";", "if", "(", "cum", "->", "mmx_nregs", "<=", "0", ")", "{", "cum", "->", "mmx_nregs", "=", "0", ";", "cum", "->", "mmx_regno", "=", "0", ";", "}", "}", "break", ";", "}", "if", "(", "error_p", ")", "{", "cum", "->", "float_in_sse", "=", "0", ";", "error", "(", "\"calling %qD with SSE calling convention without \"", "\"SSE/SSE2 enabled\"", ",", "cum", "->", "decl", ")", ";", "sorry", "(", "\"this is a GCC bug that can be worked around by adding \"", "\"attribute used to function called\"", ")", ";", "}", "return", "res", ";", "}", "</s>" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")", "Return", "a", "number", "of", "integer", "regsiters", "advanced", "over", "." ]

[ "i386", "0", "8", "0", "0", "0", "0", "0", "1", "2", "1", "1", "1", "1", "0", "0", "0", "1", "1", "0", "0", "0", "0", "\"calling %qD with SSE calling convention without \"", "\"SSE/SSE2 enabled\"", "\"this is a GCC bug that can be worked around by adding \"", "\"attribute used to function called\"" ]

[]

[ "<s>", "static", "int", "get_spec_unspec_code", "(", "const_rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "!=", "UNSPEC", ")", "return", "-", "1", ";", "{", "int", "code", ";", "code", "=", "XINT", "(", "x", ",", "1", ")", ";", "switch", "(", "code", ")", "{", "case", "UNSPEC_LDA", ":", "case", "UNSPEC_LDS", ":", "case", "UNSPEC_LDS_A", ":", "case", "UNSPEC_LDSA", ":", "return", "code", ";", "default", ":", "return", "-", "1", ";", "}", "}", "}", "</s>" ]

[ "If", "X", "is", "an", "unspec", "part", "of", "a", "speculative", "load", ",", "return", "its", "code", ".", "Return", "-1", "otherwise", "." ]

[ "ia64", "1", "1", "1" ]

[]

[ "<s>", "int", "rs6000_legitimate_address", "(", "enum", "machine_mode", "mode", ",", "rtx", "x", ",", "int", "reg_ok_strict", ")", "{", "if", "(", "TARGET_ALTIVEC", "&&", "ALTIVEC_VECTOR_MODE", "(", "mode", ")", "&&", "GET_CODE", "(", "x", ")", "==", "AND", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "-", "16", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "RS6000_SYMBOL_REF_TLS_P", "(", "x", ")", ")", "return", "0", ";", "if", "(", "legitimate_indirect_address_p", "(", "x", ",", "reg_ok_strict", ")", ")", "return", "1", ";", "if", "(", "(", "GET_CODE", "(", "x", ")", "==", "PRE_INC", "||", "GET_CODE", "(", "x", ")", "==", "PRE_DEC", ")", "&&", "!", "ALTIVEC_VECTOR_MODE", "(", "mode", ")", "&&", "!", "SPE_VECTOR_MODE", "(", "mode", ")", "&&", "!", "(", "TARGET_E500_DOUBLE", "&&", "(", "mode", "==", "DFmode", "||", "mode", "==", "DImode", ")", ")", "&&", "TARGET_UPDATE", "&&", "legitimate_indirect_address_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "reg_ok_strict", ")", ")", "return", "1", ";", "if", "(", "rs6000_legitimate_small_data_p", "(", "mode", ",", "x", ")", ")", "return", "1", ";", "if", "(", "legitimate_constant_pool_address_p", "(", "x", ")", ")", "return", "1", ";", "if", "(", "!", "reg_ok_strict", "&&", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG", "&&", "(", "XEXP", "(", "x", ",", "0", ")", "==", "virtual_stack_vars_rtx", "||", "XEXP", "(", "x", ",", "0", ")", "==", "arg_pointer_rtx", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "return", "1", ";", "if", "(", "rs6000_legitimate_offset_address_p", "(", "mode", ",", "x", ",", "reg_ok_strict", ")", ")", "return", "1", ";", "if", "(", "mode", "!=", "TImode", "&&", "mode", "!=", "TFmode", "&&", "(", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_FPRS", ")", "||", "TARGET_POWERPC64", "||", "(", "(", "mode", "!=", "DFmode", "||", "TARGET_E500_DOUBLE", ")", "&&", "mode", "!=", "TFmode", ")", ")", "&&", "(", "TARGET_POWERPC64", "||", "mode", "!=", "DImode", ")", "&&", "legitimate_indexed_address_p", "(", "x", ",", "reg_ok_strict", ")", ")", "return", "1", ";", "if", "(", "legitimate_lo_sum_address_p", "(", "mode", ",", "x", ",", "reg_ok_strict", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "GO_IF_LEGITIMATE_ADDRESS", "recognizes", "an", "RTL", "expression", "that", "is", "a", "valid", "memory", "address", "for", "an", "instruction", ".", "The", "MODE", "argument", "is", "the", "machine", "mode", "for", "the", "MEM", "expression", "that", "wants", "to", "use", "this", "address", ".", "On", "the", "RS/6000", ",", "there", "are", "four", "valid", "address", ":", "a", "SYMBOL_REF", "that", "refers", "to", "a", "constant", "pool", "entry", "of", "an", "address", "(", "or", "the", "sum", "of", "it", "plus", "a", "constant", ")", ",", "a", "short", "(", "16-bit", "signed", ")", "constant", "plus", "a", "register", ",", "the", "sum", "of", "two", "registers", ",", "or", "a", "register", "indirect", ",", "possibly", "with", "an", "auto-increment", ".", "For", "DFmode", "and", "DImode", "with", "a", "constant", "plus", "register", ",", "we", "must", "ensure", "that", "both", "words", "are", "addressable", "or", "PowerPC64", "with", "offset", "word", "aligned", ".", "For", "modes", "spanning", "multiple", "registers", "(", "DFmode", "in", "32-bit", "GPRs", ",", "32-bit", "DImode", ",", "TImode", ",", "TFmode", ")", ",", "indexed", "addressing", "can", "not", "be", "used", "because", "adjacent", "memory", "cells", "are", "accessed", "by", "adding", "word-sized", "offsets", "during", "assembly", "output", "." ]

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

[]

[ "<s>", "bool", "VETargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "assert", "(", "!", "IsVarArg", "&&", "\"TODO implement var args\"", ")", ";", "assert", "(", "Outs", ".", "empty", "(", ")", "&&", "\"TODO implement return values\"", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "VE", "VE", "ISD::OutputArg", "\"TODO implement var args\"", "\"TODO implement return values\"" ]

[]

[ "<s>", "static", "void", "ix86_run_selftests", "(", "void", ")", "{", "ix86_test_dumping_hard_regs", "(", ")", ";", "ix86_test_dumping_memory_blockage", "(", ")", ";", "ix86_test_loading_dump_fragment_1", "(", ")", ";", "ix86_test_loading_call_insn", "(", ")", ";", "ix86_test_loading_full_dump", "(", ")", ";", "ix86_test_loading_unspec", "(", ")", ";", "}", "</s>" ]

[ "Run", "all", "target-specific", "selftests", "." ]

[ "i386" ]

[]