Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "int", "ia32_multipass_dfa_lookahead", "(", "void", ")", "{", "if", "(", "reload_completed", ")", "return", "ix86_issue_rate", "(", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "How", "many", "alternative", "schedules", "to", "try", ".", "This", "should", "be", "as", "wide", "as", "the", "scheduling", "freedom", "in", "the", "DFA", ",", "but", "no", "wider", ".", "Making", "this", "value", "too", "large", "results", "extra", "work", "for", "the", "scheduler", "." ]

[ "i386", "0" ]

[]

[ "<s>", "bool", "runOnFunction", "(", "Function", "&", "F", ")", "override", "{", "TargetMachine", "*", "TM", "=", "&", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "X86LowerAMXType", "LAT", "(", "F", ",", "TM", ")", ";", "bool", "C", "=", "LAT", ".", "visit", "(", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "!", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "OptimizeNone", ")", ")", "{", "X86VolatileTileData", "VTD", "(", "F", ")", ";", "C", "=", "VTD", ".", "volatileTileData", "(", ")", "||", "C", ";", "}", "}", "return", "C", ";", "}", "</s>" ]

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

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

[]

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

[ "Return", "true", "if", "it", "is", "cheap", "to", "speculate", "a", "call", "to", "intrinsic", "ctlz", "." ]

[ "Hexagon" ]

[]

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

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

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

[]

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

[ "Add", "a", "SPARC", "builtin", "function", "with", "NAME", ",", "ICODE", ",", "CODE", "and", "TYPE", ".", "Return", "the", "function", "decl", "or", "NULL_TREE", "if", "the", "builtin", "was", "not", "added", "." ]

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

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "isBranchOffsetInRange", "(", "unsigned", "BranchOp", ",", "int64_t", "BrOffset", ")", "const", "{", "unsigned", "XLen", "=", "STI", ".", "getXLen", "(", ")", ";", "switch", "(", "BranchOp", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected opcode!\"", ")", ";", "case", "RISCV", "::", "BEQ", ":", "case", "RISCV", "::", "BNE", ":", "case", "RISCV", "::", "BLT", ":", "case", "RISCV", "::", "BGE", ":", "case", "RISCV", "::", "BLTU", ":", "case", "RISCV", "::", "BGEU", ":", "return", "isIntN", "(", "13", ",", "BrOffset", ")", ";", "case", "RISCV", "::", "JAL", ":", "case", "RISCV", "::", "PseudoBR", ":", "return", "isIntN", "(", "21", ",", "BrOffset", ")", ";", "case", "RISCV", "::", "PseudoJump", ":", "return", "isIntN", "(", "32", ",", "SignExtend64", "(", "BrOffset", "+", "0x800", ",", "XLen", ")", ")", ";", "}", "}", "</s>" ]

[ "Determine", "if", "the", "branch", "target", "is", "in", "range", "." ]

[ "RISCV", "RISCV", "\"Unexpected opcode!\"", "RISCV::BEQ", "RISCV::BNE", "RISCV::BLT", "RISCV::BGE", "RISCV::BLTU", "RISCV::BGEU", "13", "RISCV::JAL", "RISCV::PseudoBR", "21", "RISCV::PseudoJump", "32", "0x800" ]

[]

[ "<s>", "SDValue", "BPFSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "bool", "AlwaysInline", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "ConstantSDNode", "*", "ConstantSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "if", "(", "!", "ConstantSize", ")", "return", "SDValue", "(", ")", ";", "unsigned", "CopyLen", "=", "ConstantSize", "->", "getZExtValue", "(", ")", ";", "unsigned", "StoresNumEstimate", "=", "alignTo", "(", "CopyLen", ",", "Align", ")", ">>", "Log2_32", "(", "Align", ")", ";", "if", "(", "StoresNumEstimate", ">", "getCommonMaxStoresPerMemFunc", "(", ")", ")", "return", "SDValue", "(", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ",", "MVT", "::", "Glue", ")", ";", "Dst", "=", "DAG", ".", "getNode", "(", "BPFISD", "::", "MEMCPY", ",", "dl", ",", "VTs", ",", "Chain", ",", "Dst", ",", "Src", ",", "DAG", ".", "getConstant", "(", "CopyLen", ",", "dl", ",", "MVT", "::", "i64", ")", ",", "DAG", ".", "getConstant", "(", "Align", ",", "dl", ",", "MVT", "::", "i64", ")", ")", ";", "return", "Dst", ".", "getValue", "(", "0", ")", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "MVT::Other", "MVT::Glue", "BPFISD::MEMCPY", "MVT::i64", "MVT::i64", "0" ]

[]

[ "<s>", "void", "AMDGPUStructurizeCFG", "::", "analyzeLoop", "(", "BasicBlock", "*", "BB", ",", "unsigned", "&", "LoopIdx", ")", "{", "BranchInst", "*", "Term", "=", "cast", "<", "BranchInst", ">", "(", "BB", "->", "getTerminator", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Term", "->", "getNumSuccessors", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "BasicBlock", "*", "Succ", "=", "Term", "->", "getSuccessor", "(", "i", ")", ";", "if", "(", "!", "Visited", ".", "count", "(", "Succ", ")", ")", "continue", ";", "buildPredicate", "(", "Term", ",", "i", ",", "LoopPred", ",", "true", ")", ";", "LoopEnd", "=", "BB", ";", "if", "(", "Visited", "[", "Succ", "]", "<", "LoopIdx", ")", "{", "LoopIdx", "=", "Visited", "[", "Succ", "]", ";", "LoopStart", "=", "Succ", ";", "}", "}", "}", "</s>" ]

[ "Analyze", "the", "loop", "code", ",", "return", "true", "if", "it", "can", "not", "be", "understood", "." ]

[ "R600", "0" ]

[]

[ "<s>", "bool", "CJGFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "CJG", "::", "POP", ")", ",", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "CJG", "CJG", "0", "CJG::POP" ]

[]

[ "<s>", "bool", "Thumb2SizeReduce", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Modified", "|=", "ReduceMBB", "(", "*", "I", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM" ]

[]

[ "<s>", "static", "bool", "exact_dependency_1", "(", "rtx", "addr", ",", "rtx", "insn", ")", "{", "enum", "rtx_code", "code", ";", "const", "char", "*", "format_ptr", ";", "int", "i", ",", "j", ";", "code", "=", "GET_CODE", "(", "insn", ")", ";", "switch", "(", "code", ")", "{", "case", "MEM", ":", "if", "(", "rtx_equal_p", "(", "addr", ",", "insn", ")", ")", "return", "true", ";", "break", ";", "case", "REG", ":", "CASE_CONST_ANY", ":", "case", "SYMBOL_REF", ":", "case", "CODE_LABEL", ":", "case", "PC", ":", "case", "CC0", ":", "case", "EXPR_LIST", ":", "return", "false", ";", "default", ":", "break", ";", "}", "format_ptr", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "GET_RTX_LENGTH", "(", "code", ")", ";", "i", "++", ")", "{", "switch", "(", "*", "format_ptr", "++", ")", "{", "case", "'e'", ":", "if", "(", "exact_dependency_1", "(", "addr", ",", "XEXP", "(", "insn", ",", "i", ")", ")", ")", "return", "true", ";", "break", ";", "case", "'E'", ":", "for", "(", "j", "=", "0", ";", "j", "<", "XVECLEN", "(", "insn", ",", "i", ")", ";", "j", "++", ")", "if", "(", "exact_dependency_1", "(", "addr", ",", "XVECEXP", "(", "insn", ",", "i", ",", "j", ")", ")", ")", "return", "true", ";", "break", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Helper", "function", "for", "exact_store_load_dependency", ".", "Return", "true", "if", "addr", "is", "found", "in", "insn", "." ]

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

[]

[ "<s>", "rtx", "neon_make_constant", "(", "rtx", "vals", ",", "bool", "generate", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "vals", ")", ";", "rtx", "target", ";", "rtx", "const_vec", "=", "NULL_RTX", ";", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "int", "n_const", "=", "0", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "vals", ")", "==", "CONST_VECTOR", ")", "const_vec", "=", "vals", ";", "else", "if", "(", "GET_CODE", "(", "vals", ")", "==", "PARALLEL", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "++", "i", ")", "{", "rtx", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "CONST_INT_P", "(", "x", ")", "||", "CONST_DOUBLE_P", "(", "x", ")", ")", "n_const", "++", ";", "}", "if", "(", "n_const", "==", "n_elts", ")", "const_vec", "=", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "XVEC", "(", "vals", ",", "0", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "const_vec", "!=", "NULL", "&&", "simd_immediate_valid_for_move", "(", "const_vec", ",", "mode", ",", "NULL", ",", "NULL", ")", ")", "return", "const_vec", ";", "else", "if", "(", "TARGET_HAVE_MVE", "&&", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_BOOL", ")", ")", "return", "mve_bool_vec_to_const", "(", "const_vec", ")", ";", "else", "if", "(", "(", "target", "=", "neon_vdup_constant", "(", "vals", ",", "generate", ")", ")", "!=", "NULL_RTX", ")", "return", "target", ";", "else", "if", "(", "const_vec", "!=", "NULL_RTX", ")", "return", "arm_disable_literal_pool", "?", "NULL_RTX", ":", "const_vec", ";", "else", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Generate", "code", "to", "load", "VALS", ",", "which", "is", "a", "PARALLEL", "containing", "only", "constants", "(", "for", "vec_init", ")", "or", "CONST_VECTOR", ",", "efficiently", "into", "a", "register", ".", "Returns", "an", "RTX", "to", "copy", "into", "the", "register", ",", "or", "NULL_RTX", "for", "a", "PARALLEL", "that", "can", "not", "be", "converted", "into", "a", "CONST_VECTOR", "." ]

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

[]

[ "<s>", "static", "void", "replace_mov_pcrel_step2", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "unspec", ";", "rtx", "addr", ";", "rtx", "opnds", "[", "3", "]", ";", "rtx_insn", "*", "new_insns", ";", "rtx", "got_rtx", "=", "tilegx_got_rtx", "(", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "pattern", ")", "==", "SET", ")", ";", "opnds", "[", "0", "]", "=", "SET_DEST", "(", "pattern", ")", ";", "unspec", "=", "SET_SRC", "(", "pattern", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "unspec", ")", "==", "UNSPEC", ")", ";", "gcc_assert", "(", "XINT", "(", "unspec", ",", "1", ")", "==", "UNSPEC_INSN_ADDR_SHL16INSLI", ")", ";", "opnds", "[", "1", "]", "=", "XVECEXP", "(", "unspec", ",", "0", ",", "0", ")", ";", "addr", "=", "XVECEXP", "(", "unspec", ",", "0", ",", "1", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "addr", ")", "==", "CONST", ")", ";", "unspec", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "unspec", ")", "==", "UNSPEC", ")", ";", "gcc_assert", "(", "XINT", "(", "unspec", ",", "1", ")", "==", "UNSPEC_HW0_PCREL", ")", ";", "opnds", "[", "2", "]", "=", "XVECEXP", "(", "unspec", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "opnds", "[", "2", "]", ")", "!=", "SYMBOL_REF", ")", "return", ";", "start_sequence", "(", ")", ";", "if", "(", "flag_pic", "==", "1", ")", "{", "if", "(", "TARGET_32BIT", ")", "emit_insn", "(", "gen_add_got16_32bit", "(", "opnds", "[", "0", "]", ",", "got_rtx", ",", "opnds", "[", "2", "]", ")", ")", ";", "else", "emit_insn", "(", "gen_add_got16", "(", "opnds", "[", "0", "]", ",", "got_rtx", ",", "opnds", "[", "2", "]", ")", ")", ";", "}", "else", "{", "if", "(", "TARGET_32BIT", ")", "emit_insn", "(", "gen_mov_got32_step2_32bit", "(", "opnds", "[", "0", "]", ",", "opnds", "[", "1", "]", ",", "opnds", "[", "2", "]", ")", ")", ";", "else", "emit_insn", "(", "gen_mov_got32_step2", "(", "opnds", "[", "0", "]", ",", "opnds", "[", "1", "]", ",", "opnds", "[", "2", "]", ")", ")", ";", "}", "new_insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "replace_insns", "(", "insn", ",", "new_insns", ")", ";", "}", "</s>" ]

[ "Do", "the", "second", "replacement", "step", "in", "tilegx_fixup_pcrel_references", "." ]

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

[]

[ "<s>", "Value", "*", "AArch64TargetLowering", "::", "emitLoadLinked", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Type", "*", "ValTy", "=", "cast", "<", "PointerType", ">", "(", "Addr", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ";", "bool", "IsAcquire", "=", "isAtLeastAcquire", "(", "Ord", ")", ";", "if", "(", "ValTy", "->", "getPrimitiveSizeInBits", "(", ")", "==", "128", ")", "{", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "aarch64_ldaxp", ":", "Intrinsic", "::", "aarch64_ldxp", ";", "Function", "*", "Ldxr", "=", "llvm", "::", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "Value", "*", "LoHi", "=", "Builder", ".", "CreateCall", "(", "Ldxr", ",", "Addr", ",", "\"lohi\"", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "0", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "1", ",", "\"hi\"", ")", ";", "Lo", "=", "Builder", ".", "CreateZExt", "(", "Lo", ",", "ValTy", ",", "\"lo64\"", ")", ";", "Hi", "=", "Builder", ".", "CreateZExt", "(", "Hi", ",", "ValTy", ",", "\"hi64\"", ")", ";", "return", "Builder", ".", "CreateOr", "(", "Lo", ",", "Builder", ".", "CreateShl", "(", "Hi", ",", "ConstantInt", "::", "get", "(", "ValTy", ",", "64", ")", ")", ",", "\"val64\"", ")", ";", "}", "Type", "*", "Tys", "[", "]", "=", "{", "Addr", "->", "getType", "(", ")", "}", ";", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "aarch64_ldaxr", ":", "Intrinsic", "::", "aarch64_ldxr", ";", "Function", "*", "Ldxr", "=", "llvm", "::", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ",", "Tys", ")", ";", "return", "Builder", ".", "CreateTruncOrBitCast", "(", "Builder", ".", "CreateCall", "(", "Ldxr", ",", "Addr", ")", ",", "cast", "<", "PointerType", ">", "(", "Addr", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ")", ";", "}", "</s>" ]

[ "Perform", "a", "load-linked", "operation", "on", "Addr", ",", "returning", "a", "``", "Value", "*", "''", "with", "the", "corresponding", "pointee", "type", "." ]

[ "AArch64", "AArch64", "128", "Intrinsic::ID", "Intrinsic::aarch64_ldaxp", "Intrinsic::aarch64_ldxp", "Intrinsic::getDeclaration", "\"lohi\"", "0", "\"lo\"", "1", "\"hi\"", "\"lo64\"", "\"hi64\"", "64", "\"val64\"", "Intrinsic::ID", "Intrinsic::aarch64_ldaxr", "Intrinsic::aarch64_ldxr", "Intrinsic::getDeclaration" ]

[]

[ "<s>", "void", "VEInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "if", "(", "RC", "==", "&", "VE", "::", "I64RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "STSri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "VE", "::", "I32RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "STLri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "VE", "::", "F32RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "STUri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "report_fatal_error", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "</s>" ]

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

[ "VE", "VE", "VE::I64RegClass", "VE::STSri", "0", "VE::I32RegClass", "VE::STLri", "0", "VE::F32RegClass", "VE::STUri", "0", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "void", "loongarch_expand_scc", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "target", "=", "operands", "[", "0", "]", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "op0", "=", "operands", "[", "2", "]", ";", "rtx", "op1", "=", "operands", "[", "3", "]", ";", "loongarch_extend_comparands", "(", "code", ",", "&", "op0", ",", "&", "op1", ")", ";", "op0", "=", "force_reg", "(", "word_mode", ",", "op0", ")", ";", "gcc_assert", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "op0", ")", ")", "==", "MODE_INT", ")", ";", "if", "(", "code", "==", "EQ", "||", "code", "==", "NE", ")", "{", "rtx", "zie", "=", "loongarch_zero_if_equal", "(", "op0", ",", "op1", ")", ";", "loongarch_emit_binary", "(", "code", ",", "target", ",", "zie", ",", "const0_rtx", ")", ";", "}", "else", "loongarch_emit_int_order_test", "(", "code", ",", "0", ",", "target", ",", "op0", ",", "op1", ")", ";", "}", "</s>" ]

[ "Try", "performing", "the", "comparison", "in", "OPERANDS", "[", "1", "]", ",", "whose", "arms", "are", "OPERANDS", "[", "2", "]", "and", "OPERAND", "[", "3", "]", ".", "Store", "the", "result", "in", "OPERANDS", "[", "0", "]", ".", "On", "64-bit", "targets", ",", "the", "mode", "of", "the", "comparison", "and", "target", "will", "always", "be", "SImode", ",", "thus", "possibly", "narrower", "than", "that", "of", "the", "comparison", "'s", "operands", "." ]

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

[]

[ "<s>", "void", "ARMPassConfig", "::", "addPreSched2", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableARMLoadStoreOpt", ")", "addPass", "(", "createARMLoadStoreOptimizationPass", "(", ")", ")", ";", "addPass", "(", "new", "ARMExecutionDomainFix", "(", ")", ")", ";", "addPass", "(", "createBreakFalseDeps", "(", ")", ")", ";", "}", "addPass", "(", "createARMExpandPseudoPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createThumb2SizeReductionPass", "(", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "this", "->", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ".", "restrictIT", "(", ")", ";", "}", ")", ")", ";", "addPass", "(", "createIfConverter", "(", "[", "]", "(", "const", "MachineFunction", "&", "MF", ")", "{", "return", "!", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isThumb1Only", "(", ")", ";", "}", ")", ")", ";", "}", "addPass", "(", "createMVEVPTBlockPass", "(", ")", ")", ";", "addPass", "(", "createThumb2ITBlockPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "&", "PostMachineSchedulerID", ")", ";", "addPass", "(", "&", "PostRASchedulerID", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "enum", "aarch64_parse_opt_result", "aarch64_parse_cpu", "(", "const", "char", "*", "to_parse", ",", "const", "struct", "processor", "*", "*", "res", ",", "unsigned", "long", "*", "isa_flags", ",", "std", "::", "string", "*", "invalid_extension", ")", "{", "const", "char", "*", "ext", ";", "const", "struct", "processor", "*", "cpu", ";", "size_t", "len", ";", "ext", "=", "strchr", "(", "to_parse", ",", "'+'", ")", ";", "if", "(", "ext", "!=", "NULL", ")", "len", "=", "ext", "-", "to_parse", ";", "else", "len", "=", "strlen", "(", "to_parse", ")", ";", "if", "(", "len", "==", "0", ")", "return", "AARCH64_PARSE_MISSING_ARG", ";", "for", "(", "cpu", "=", "all_cores", ";", "cpu", "->", "name", "!=", "NULL", ";", "cpu", "++", ")", "{", "if", "(", "strlen", "(", "cpu", "->", "name", ")", "==", "len", "&&", "strncmp", "(", "cpu", "->", "name", ",", "to_parse", ",", "len", ")", "==", "0", ")", "{", "unsigned", "long", "isa_temp", "=", "cpu", "->", "flags", ";", "if", "(", "ext", "!=", "NULL", ")", "{", "enum", "aarch64_parse_opt_result", "ext_res", "=", "aarch64_parse_extension", "(", "ext", ",", "&", "isa_temp", ",", "invalid_extension", ")", ";", "if", "(", "ext_res", "!=", "AARCH64_PARSE_OK", ")", "return", "ext_res", ";", "}", "*", "res", "=", "cpu", ";", "*", "isa_flags", "=", "isa_temp", ";", "return", "AARCH64_PARSE_OK", ";", "}", "}", "return", "AARCH64_PARSE_INVALID_ARG", ";", "}", "</s>" ]

[ "Parse", "the", "TO_PARSE", "string", "and", "put", "the", "result", "tuning", "in", "RES", "and", "the", "architecture", "flags", "in", "ISA_FLAGS", ".", "Return", "an", "aarch64_parse_opt_result", "describing", "the", "parse", "result", ".", "If", "there", "is", "an", "error", "parsing", ",", "RES", "and", "ISA_FLAGS", "are", "left", "unchanged", "." ]

[ "aarch64", "0", "0" ]

[]

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "INDIRECT_BASE_ADDR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "EXEC", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "FLAT_SCR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "M0", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_SHARED_BASE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_SHARED_LIMIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_PRIVATE_BASE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_PRIVATE_LIMIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TBA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TMA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP0_TTMP1", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP2_TTMP3", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP4_TTMP5", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP6_TTMP7", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP8_TTMP9", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP10_TTMP11", ")", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "unsigned", "MaxNumSGPRs", "=", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumSGPRs", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumSGPRs", ";", "i", "<", "TotalNumSGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "unsigned", "MaxNumVGPRs", "=", "ST", ".", "getMaxNumVGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumVGPRs", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumVGPRs", ";", "i", "<", "TotalNumVGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "ScratchWaveOffsetReg", "=", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ";", "if", "(", "ScratchWaveOffsetReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchWaveOffsetReg", ")", ";", "}", "unsigned", "ScratchRSrcReg", "=", "MFI", "->", "getScratchRSrcReg", "(", ")", ";", "if", "(", "ScratchRSrcReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchRSrcReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "ScratchWaveOffsetReg", ")", ")", ";", "}", "unsigned", "StackPtrReg", "=", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ";", "if", "(", "StackPtrReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "StackPtrReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "StackPtrReg", ")", ")", ";", "}", "unsigned", "FrameReg", "=", "MFI", "->", "getFrameOffsetReg", "(", ")", ";", "if", "(", "FrameReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "FrameReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "FrameReg", ")", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::INDIRECT_BASE_ADDR", "AMDGPU::EXEC", "AMDGPU::FLAT_SCR", "AMDGPU::M0", "AMDGPU::SRC_SHARED_BASE", "AMDGPU::SRC_SHARED_LIMIT", "AMDGPU::SRC_PRIVATE_BASE", "AMDGPU::SRC_PRIVATE_LIMIT", "AMDGPU::TBA", "AMDGPU::TMA", "AMDGPU::TTMP0_TTMP1", "AMDGPU::TTMP2_TTMP3", "AMDGPU::TTMP4_TTMP5", "AMDGPU::TTMP6_TTMP7", "AMDGPU::TTMP8_TTMP9", "AMDGPU::TTMP10_TTMP11", "SI", "SI", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "SI", "SI", "AMDGPU::NoRegister", "AMDGPU::NoRegister", "AMDGPU::NoRegister", "AMDGPU::NoRegister" ]

[]

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

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

[ "Comet2", "Comet2" ]

[]

[ "<s>", "static", "unsigned", "addLiveIn", "(", "MachineFunction", "&", "MF", ",", "unsigned", "PReg", ",", "const", "TargetRegisterClass", "*", "RC", ")", "{", "unsigned", "VReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveIn", "(", "PReg", ",", "VReg", ")", ";", "return", "VReg", ";", "}", "</s>" ]

[ "addLiveIn", "-", "Add", "the", "specified", "register", "as", "a", "live-in", "." ]

[ "P2" ]

[]

[ "<s>", "AArch64TargetMachine", "::", "AArch64TargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "InstrInfo", "(", "Subtarget", ")", ",", "DL", "(", "\"e-p:64:64-i64:64:64-i128:128:128-s0:32:32-f128:128:128-n32:64-S128\"", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "TSInfo", "(", "*", "this", ")", ",", "FrameLowering", "(", "Subtarget", ")", "{", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"e-p:64:64-i64:64:64-i128:128:128-s0:32:32-f128:128:128-n32:64-S128\"" ]

[]

[ "<s>", "void", "R600SchedStrategy", "::", "releaseTopNode", "(", "SUnit", "*", "SU", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Top Releasing \"", ";", "SU", "->", "dump", "(", "DAG", ")", ";", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "\"Top Releasing \"" ]

[]

[ "<s>", "bool", "MachineModulePass", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "bool", "Changed", "=", "runOnMachineModule", "(", "M", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "Patmos" ]

[]

[ "<s>", "static", "inline", "bool", "mode_supports_pre_incdec_p", "(", "machine_mode", "mode", ")", "{", "return", "(", "(", "reg_addr", "[", "mode", "]", ".", "addr_mask", "[", "RELOAD_REG_ANY", "]", "&", "RELOAD_REG_PRE_INCDEC", ")", "!=", "0", ")", ";", "}", "</s>" ]

[ "Helper", "function", "to", "say", "whether", "a", "mode", "supports", "PRE_INC", "or", "PRE_DEC", "." ]

[ "powerpcspe", "0" ]

[]

[ "<s>", "bool", "SystemZShortenInst", "::", "processBlock", "(", "MachineBasicBlock", "&", "MBB", ")", "{", "bool", "Changed", "=", "false", ";", "unsigned", "LiveLow", "=", "0", ";", "unsigned", "LiveHigh", "=", "0", ";", "for", "(", "auto", "SI", "=", "MBB", ".", "succ_begin", "(", ")", ",", "SE", "=", "MBB", ".", "succ_end", "(", ")", ";", "SI", "!=", "SE", ";", "++", "SI", ")", "{", "for", "(", "auto", "LI", "=", "(", "*", "SI", ")", "->", "livein_begin", "(", ")", ",", "LE", "=", "(", "*", "SI", ")", "->", "livein_end", "(", ")", ";", "LI", "!=", "LE", ";", "++", "LI", ")", "{", "unsigned", "Reg", "=", "*", "LI", ";", "assert", "(", "Reg", "<", "SystemZ", "::", "NUM_TARGET_REGS", "&&", "\"Invalid register number\"", ")", ";", "LiveLow", "|=", "LowGPRs", "[", "Reg", "]", ";", "LiveHigh", "|=", "HighGPRs", "[", "Reg", "]", ";", "}", "}", "for", "(", "auto", "MBBI", "=", "MBB", ".", "rbegin", "(", ")", ",", "MBBE", "=", "MBB", ".", "rend", "(", ")", ";", "MBBI", "!=", "MBBE", ";", "++", "MBBI", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "SystemZ", "::", "IILF", ")", "Changed", "|=", "shortenIIF", "(", "MI", ",", "LowGPRs", ",", "LiveHigh", ",", "SystemZ", "::", "LLILL", ",", "SystemZ", "::", "LLILH", ")", ";", "else", "if", "(", "Opcode", "==", "SystemZ", "::", "IIHF", ")", "Changed", "|=", "shortenIIF", "(", "MI", ",", "HighGPRs", ",", "LiveLow", ",", "SystemZ", "::", "LLIHL", ",", "SystemZ", "::", "LLIHH", ")", ";", "unsigned", "UsedLow", "=", "0", ";", "unsigned", "UsedHigh", "=", "0", ";", "for", "(", "auto", "MOI", "=", "MI", ".", "operands_begin", "(", ")", ",", "MOE", "=", "MI", ".", "operands_end", "(", ")", ";", "MOI", "!=", "MOE", ";", "++", "MOI", ")", "{", "MachineOperand", "&", "MO", "=", "*", "MOI", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "if", "(", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ")", "{", "assert", "(", "Reg", "<", "SystemZ", "::", "NUM_TARGET_REGS", "&&", "\"Invalid register number\"", ")", ";", "if", "(", "MO", ".", "isDef", "(", ")", ")", "{", "LiveLow", "&=", "~", "LowGPRs", "[", "Reg", "]", ";", "LiveHigh", "&=", "~", "HighGPRs", "[", "Reg", "]", ";", "}", "else", "if", "(", "!", "MO", ".", "isUndef", "(", ")", ")", "{", "UsedLow", "|=", "LowGPRs", "[", "Reg", "]", ";", "UsedHigh", "|=", "HighGPRs", "[", "Reg", "]", ";", "}", "}", "}", "}", "LiveLow", "|=", "UsedLow", ";", "LiveHigh", "|=", "UsedHigh", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "processBlock", "-", "If", "there", "are", "any", "predecessors", "whose", "control", "can", "be", "threaded", "through", "to", "a", "successor", ",", "transform", "them", "now", "." ]

[ "SystemZ", "SystemZ", "0", "0", "SystemZ::NUM_TARGET_REGS", "\"Invalid register number\"", "SystemZ::IILF", "SystemZ::LLILL", "SystemZ::LLILH", "SystemZ::IIHF", "SystemZ::LLIHL", "SystemZ::LLIHH", "0", "0", "SystemZ::NUM_TARGET_REGS", "\"Invalid register number\"" ]

[]

[ "<s>", "void", "HexagonAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "std", "::", "vector", "<", "const", "MachineInstr", "*", ">", "BundleMIs", ";", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "MII", "=", "MI", ";", "++", "MII", ";", "unsigned", "int", "IgnoreCount", "=", "0", ";", "while", "(", "MII", "!=", "MBB", "->", "end", "(", ")", "&&", "MII", "->", "isInsideBundle", "(", ")", ")", "{", "const", "MachineInstr", "*", "MInst", "=", "MII", ";", "if", "(", "MInst", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "DBG_VALUE", "||", "MInst", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "IMPLICIT_DEF", ")", "{", "IgnoreCount", "++", ";", "++", "MII", ";", "continue", ";", "}", "BundleMIs", ".", "push_back", "(", "MInst", ")", ";", "++", "MII", ";", "}", "unsigned", "Size", "=", "BundleMIs", ".", "size", "(", ")", ";", "assert", "(", "(", "Size", "+", "IgnoreCount", ")", "==", "MI", "->", "getBundleSize", "(", ")", "&&", "\"Corrupt Bundle!\"", ")", ";", "for", "(", "unsigned", "Index", "=", "0", ";", "Index", "<", "Size", ";", "Index", "++", ")", "{", "HexagonMCInst", "MCI", ";", "MCI", ".", "setPacketStart", "(", "Index", "==", "0", ")", ";", "MCI", ".", "setPacketEnd", "(", "Index", "==", "(", "Size", "-", "1", ")", ")", ";", "HexagonLowerToMC", "(", "BundleMIs", "[", "Index", "]", ",", "MCI", ",", "*", "this", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "MCI", ")", ";", "}", "}", "else", "{", "HexagonMCInst", "MCI", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "ENDLOOP0", ")", "{", "MCI", ".", "setPacketStart", "(", "true", ")", ";", "MCI", ".", "setPacketEnd", "(", "true", ")", ";", "}", "HexagonLowerToMC", "(", "MI", ",", "MCI", ",", "*", "this", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "MCI", ")", ";", "}", "return", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "\"Corrupt Bundle!\"", "0", "Hexagon", "0", "1", "Hexagon", "Hexagon", "Hexagon::ENDLOOP0", "Hexagon" ]

[]

[ "<s>", "unsigned", "ARCInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "INLINEASM", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "char", "*", "AsmStr", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ";", "return", "getInlineAsmLength", "(", "AsmStr", ",", "*", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "return", "MI", ".", "getDesc", "(", ")", ".", "getSize", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "arm_needs_doubleword_align", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "!", "type", ")", "return", "PARM_BOUNDARY", "<", "GET_MODE_ALIGNMENT", "(", "mode", ")", ";", "if", "(", "!", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "return", "TYPE_ALIGN", "(", "TYPE_MAIN_VARIANT", "(", "type", ")", ")", ">", "PARM_BOUNDARY", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "return", "TYPE_ALIGN", "(", "TREE_TYPE", "(", "type", ")", ")", ">", "PARM_BOUNDARY", ";", "for", "(", "tree", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "DECL_CHAIN", "(", "field", ")", ")", "if", "(", "DECL_ALIGN", "(", "field", ")", ">", "PARM_BOUNDARY", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "1", "if", "double", "word", "alignment", "is", "required", "for", "argument", "passing", ".", "Return", "-1", "if", "double", "word", "alignment", "used", "to", "be", "required", "for", "argument", "passing", "before", "PR77728", "ABI", "fix", ",", "but", "is", "not", "required", "anymore", ".", "Return", "0", "if", "double", "word", "alignment", "is", "not", "required", "and", "was", "n't", "requried", "before", "either", "." ]

[ "arm" ]

[]

[ "<s>", "static", "bool", "aarch64_validate_mcpu", "(", "const", "char", "*", "str", ",", "const", "struct", "processor", "*", "*", "res", ",", "unsigned", "long", "*", "isa_flags", ")", "{", "enum", "aarch64_parse_opt_result", "parse_res", "=", "aarch64_parse_cpu", "(", "str", ",", "res", ",", "isa_flags", ")", ";", "if", "(", "parse_res", "==", "AARCH64_PARSE_OK", ")", "return", "true", ";", "switch", "(", "parse_res", ")", "{", "case", "AARCH64_PARSE_MISSING_ARG", ":", "error", "(", "\"missing cpu name in -mcpu=%qs\"", ",", "str", ")", ";", "break", ";", "case", "AARCH64_PARSE_INVALID_ARG", ":", "error", "(", "\"unknown value %qs for -mcpu\"", ",", "str", ")", ";", "break", ";", "case", "AARCH64_PARSE_INVALID_FEATURE", ":", "error", "(", "\"invalid feature modifier in -mcpu=%qs\"", ",", "str", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Validate", "a", "command-line", "-mcpu", "option", ".", "Parse", "the", "cpu", "and", "extensions", "(", "if", "any", ")", "specified", "in", "STR", "and", "throw", "errors", "if", "appropriate", ".", "Put", "the", "results", "if", "they", "are", "valid", "in", "RES", "and", "ISA_FLAGS", ".", "Return", "whether", "the", "option", "is", "valid", "." ]

[ "aarch64", "\"missing cpu name in -mcpu=%qs\"", "\"unknown value %qs for -mcpu\"", "\"invalid feature modifier in -mcpu=%qs\"" ]

[]

[ "<s>", "const_iterator", "begin", "(", ")", "const", "{", "return", "Map", ".", "begin", "(", ")", ";", "}", "</s>" ]

[ "Recipe", "iterator", "methods", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "R600InstrInfo", "::", "reserveIndirectRegisters", "(", "BitVector", "&", "Reserved", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "R600Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "R600Subtarget", ">", "(", ")", ";", "const", "R600FrameLowering", "*", "TFL", "=", "ST", ".", "getFrameLowering", "(", ")", ";", "unsigned", "StackWidth", "=", "TFL", "->", "getStackWidth", "(", "MF", ")", ";", "int", "End", "=", "getIndirectIndexEnd", "(", "MF", ")", ";", "if", "(", "End", "==", "-", "1", ")", "return", ";", "for", "(", "int", "Index", "=", "getIndirectIndexBegin", "(", "MF", ")", ";", "Index", "<=", "End", ";", "++", "Index", ")", "{", "unsigned", "SuperReg", "=", "AMDGPU", "::", "R600_Reg128RegClass", ".", "getRegister", "(", "Index", ")", ";", "Reserved", ".", "set", "(", "SuperReg", ")", ";", "for", "(", "unsigned", "Chan", "=", "0", ";", "Chan", "<", "StackWidth", ";", "++", "Chan", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "R600_TReg32RegClass", ".", "getRegister", "(", "(", "4", "*", "Index", ")", "+", "Chan", ")", ";", "Reserved", ".", "set", "(", "Reg", ")", ";", "}", "}", "}", "</s>" ]

[ "Reserve", "the", "registers", "that", "may", "be", "accessed", "using", "indirect", "addressing", "." ]

[ "AMDGPU", "R600", "R600", "R600", "R600", "1", "AMDGPU::R600_Reg128RegClass", "0", "AMDGPU::R600_TReg32RegClass", "4" ]

[]

[ "<s>", "MVT", "SITargetLowering", "::", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", ",", "EVT", "VT", ")", "const", "{", "return", "(", "VT", "==", "MVT", "::", "i16", ")", "?", "MVT", "::", "i16", ":", "MVT", "::", "i32", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "MVT::i16", "MVT::i16", "MVT::i32" ]

[]

[ "<s>", "static", "bool", "nds32_symbol_binds_local_p", "(", "const_rtx", "x", ")", "{", "return", "(", "SYMBOL_REF_DECL", "(", "x", ")", "?", "targetm", ".", "binds_local_p", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", ":", "SYMBOL_REF_LOCAL_P", "(", "x", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "SYMBOL_REF", "X", "binds", "locally", "." ]

[ "nds32" ]

[]

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

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

[ "WebAssembly" ]

[]

[ "<s>", "bool", "shouldTransformSignedTruncationCheck", "(", "EVT", "XVT", ",", "unsigned", "KeptBits", ")", "const", "override", "{", "if", "(", "XVT", ".", "isVector", "(", ")", ")", "return", "false", ";", "auto", "VTIsOk", "=", "[", "]", "(", "EVT", "VT", ")", "->", "bool", "{", "return", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i64", ";", "}", ";", "MVT", "KeptBitsVT", "=", "MVT", "::", "getIntegerVT", "(", "KeptBits", ")", ";", "return", "VTIsOk", "(", "XVT", ")", "&&", "VTIsOk", "(", "KeptBitsVT", ")", ";", "}", "</s>" ]

[ "Should", "we", "tranform", "the", "IR-optimal", "check", "for", "whether", "given", "truncation", "down", "into", "KeptBits", "would", "be", "truncating", "or", "not", ":", "(", "add", "x", ",", "(", "1", "<", "<", "(", "KeptBits-1", ")", ")", ")", "srccond", "(", "1", "<", "<", "KeptBits", ")", "Into", "it", "'s", "more", "traditional", "form", ":", "(", "(", "x", "<", "<", "C", ")", "a", ">", ">", "C", ")", "dstcond", "x", "Return", "true", "if", "we", "should", "transform", "." ]

[ "X86", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::i64", "MVT::getIntegerVT" ]

[]

[ "<s>", "static", "rtx", "nvptx_function_value", "(", "const_tree", "type", ",", "const_tree", "ARG_UNUSED", "(", "func", ")", ",", "bool", "outgoing", ")", "{", "machine_mode", "mode", "=", "promote_return", "(", "TYPE_MODE", "(", "type", ")", ")", ";", "if", "(", "outgoing", ")", "{", "cfun", "->", "machine", "->", "return_mode", "=", "mode", ";", "return", "gen_rtx_REG", "(", "mode", ",", "NVPTX_RETURN_REGNUM", ")", ";", "}", "return", "nvptx_libcall_value", "(", "mode", ",", "NULL_RTX", ")", ";", "}", "</s>" ]

[ "TARGET_FUNCTION_VALUE", "implementation", ".", "Returns", "an", "RTX", "representing", "the", "place", "where", "function", "FUNC", "returns", "or", "receives", "a", "value", "of", "data", "type", "TYPE", "." ]

[ "nvptx" ]

[]

[ "<s>", "bool", "SILoadStoreOptimizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "STM", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "!", "STM", "->", "loadStoreOptEnabled", "(", ")", ")", "return", "false", ";", "TII", "=", "STM", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "assert", "(", "MRI", "->", "isSSA", "(", ")", "&&", "\"Must be run on SSA\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Running SILoadStoreOptimizer\\n\"", ")", ";", "bool", "Modified", "=", "false", ";", "SmallPtrSet", "<", "MachineInstr", "*", ",", "4", ">", "AnchorList", ";", "MemInfoMap", "Visited", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "::", "iterator", "SectionEnd", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "SectionEnd", ")", "{", "bool", "CollectModified", ";", "std", "::", "list", "<", "std", "::", "list", "<", "CombineInfo", ">>", "MergeableInsts", ";", "std", "::", "tie", "(", "SectionEnd", ",", "CollectModified", ")", "=", "collectMergeableInsts", "(", "I", ",", "E", ",", "Visited", ",", "AnchorList", ",", "MergeableInsts", ")", ";", "Modified", "|=", "CollectModified", ";", "do", "{", "OptimizeAgain", "=", "false", ";", "Modified", "|=", "optimizeBlock", "(", "MergeableInsts", ")", ";", "}", "while", "(", "OptimizeAgain", ")", ";", "}", "Visited", ".", "clear", "(", ")", ";", "AnchorList", ".", "clear", "(", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "\"Must be run on SSA\"", "\"Running SILoadStoreOptimizer\\n\"", "4" ]

[]

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

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

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

[]

[ "<s>", "static", "bool", "rx_small_data_operand", "(", "rtx", "op", ")", "{", "if", "(", "rx_small_data_limit", "==", "0", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", ")", "return", "SYMBOL_REF_SMALL_P", "(", "op", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "reference", "to", "an", "object", "in", "a", "small", "data", "area", "." ]

[ "rx", "0" ]

[]

[ "<s>", "static", "rtx", "pa_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "fun", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "!", "TARGET_SOFT_FLOAT", "&&", "(", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", ")", ")", "return", "gen_rtx_REG", "(", "mode", ",", "32", ")", ";", "else", "return", "gen_rtx_REG", "(", "mode", ",", "28", ")", ";", "}", "</s>" ]

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

[ "pa", "32", "28" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "auto", "E", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "E", ")", "return", "false", ";", "while", "(", "I", "!=", "E", "&&", "!", "I", "->", "isBranch", "(", ")", "&&", "!", "I", "->", "isReturn", "(", ")", "&&", "I", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "SI_MASK_BRANCH", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_MASK_BRANCH", ":", "case", "AMDGPU", "::", "S_MOV_B64_term", ":", "case", "AMDGPU", "::", "S_XOR_B64_term", ":", "case", "AMDGPU", "::", "S_ANDN2_B64_term", ":", "break", ";", "case", "AMDGPU", "::", "SI_IF", ":", "case", "AMDGPU", "::", "SI_ELSE", ":", "case", "AMDGPU", "::", "SI_KILL_I1_TERMINATOR", ":", "case", "AMDGPU", "::", "SI_KILL_F32_COND_IMM_TERMINATOR", ":", "return", "true", ";", "default", ":", "llvm_unreachable", "(", "\"unexpected non-branch terminator inst\"", ")", ";", "}", "++", "I", ";", "}", "if", "(", "I", "==", "E", ")", "return", "false", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "SI_MASK_BRANCH", ")", "return", "analyzeBranchImpl", "(", "MBB", ",", "I", ",", "TBB", ",", "FBB", ",", "Cond", ",", "AllowModify", ")", ";", "++", "I", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "true", ";", "if", "(", "analyzeBranchImpl", "(", "MBB", ",", "I", ",", "TBB", ",", "FBB", ",", "Cond", ",", "AllowModify", ")", ")", "return", "true", ";", "MachineBasicBlock", "*", "MaskBrDest", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "if", "(", "TBB", "!=", "MaskBrDest", "||", "Cond", ".", "empty", "(", ")", ")", "return", "true", ";", "auto", "Pred", "=", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "return", "(", "Pred", "!=", "EXECZ", "&&", "Pred", "!=", "EXECNZ", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::SI_MASK_BRANCH", "AMDGPU::SI_MASK_BRANCH", "AMDGPU::S_MOV_B64_term", "AMDGPU::S_XOR_B64_term", "AMDGPU::S_ANDN2_B64_term", "AMDGPU::SI_IF", "AMDGPU::SI_ELSE", "AMDGPU::SI_KILL_I1_TERMINATOR", "AMDGPU::SI_KILL_F32_COND_IMM_TERMINATOR", "\"unexpected non-branch terminator inst\"", "AMDGPU::SI_MASK_BRANCH", "0", "0" ]

[]

[ "<s>", "bool", "BPFAbstractMemberAccess", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Abstract Member Accesses **********\\n\"", ")", ";", "if", "(", "M", ".", "debug_compile_units", "(", ")", ".", "empty", "(", ")", ")", "return", "false", ";", "DL", "=", "&", "M", ".", "getDataLayout", "(", ")", ";", "return", "doTransformation", "(", "M", ")", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "\"********** Abstract Member Accesses **********\\n\"" ]

[]

[ "<s>", "bool", "frv_const_unspec_p", "(", "rtx", "x", ",", "struct", "frv_unspec", "*", "unspec", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "{", "unspec", "->", "offset", "=", "0", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "unspec", "->", "offset", "+=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOT", ")", "{", "unspec", "->", "symbol", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "unspec", "->", "reloc", "=", "INTVAL", "(", "XVECEXP", "(", "x", ",", "0", ",", "1", ")", ")", ";", "if", "(", "unspec", "->", "offset", "==", "0", ")", "return", "true", ";", "if", "(", "frv_small_data_reloc_p", "(", "unspec", "->", "symbol", ",", "unspec", "->", "reloc", ")", "&&", "unspec", "->", "offset", ">", "0", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "unspec", "->", "offset", "<", "g_switch_value", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "relocation", "unspec", ".", "If", "it", "is", ",", "fill", "in", "UNSPEC", "appropriately", "." ]

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

[]

[ "<s>", "static", "void", "tilegx_asm_trampoline_template", "(", "FILE", "*", "file", ")", "{", "int", "ptr_mode_size", "=", "GET_MODE_SIZE", "(", "ptr_mode", ")", ";", "if", "(", "TARGET_32BIT", ")", "{", "fprintf", "(", "file", ",", "\"\\tlnk r10\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\taddxi r10, r10, 32\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tld4s_add r11, r10, %d\\n\"", ",", "ptr_mode_size", ")", ";", "fprintf", "(", "file", ",", "\"\\tld4s r10, r10\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tjr r11\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t.word 0 # <function address>\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t.word 0 # <static chain value>\\n\"", ")", ";", "}", "else", "{", "fprintf", "(", "file", ",", "\"\\tlnk r10\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\taddi r10, r10, 32\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tld_add r11, r10, %d\\n\"", ",", "ptr_mode_size", ")", ";", "fprintf", "(", "file", ",", "\"\\tld r10, r10\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tjr r11\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t.quad 0 # <function address>\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t.quad 0 # <static chain value>\\n\"", ")", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_ASM_TRAMPOLINE_TEMPLATE", "." ]

[ "tilegx", "\"\\tlnk r10\\n\"", "\"\\taddxi r10, r10, 32\\n\"", "\"\\tld4s_add r11, r10, %d\\n\"", "\"\\tld4s r10, r10\\n\"", "\"\\tjr r11\\n\"", "\"\\t.word 0 # <function address>\\n\"", "\"\\t.word 0 # <static chain value>\\n\"", "\"\\tlnk r10\\n\"", "\"\\taddi r10, r10, 32\\n\"", "\"\\tld_add r11, r10, %d\\n\"", "\"\\tld r10, r10\\n\"", "\"\\tjr r11\\n\"", "\"\\t.quad 0 # <function address>\\n\"", "\"\\t.quad 0 # <static chain value>\\n\"" ]

[]

[ "<s>", "static", "bool", "insn_ok_now", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "int", "i", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "if", "(", "recog", "(", "pattern", ",", "insn", ",", "0", ")", ">", "-", "1", ")", "{", "extract_insn", "(", "insn", ")", ";", "if", "(", "constrain_operands", "(", "1", ",", "get_preferred_alternatives", "(", "insn", ")", ")", ")", "{", "fprintf", "(", "stderr", ",", "\"\\033[32m\"", ")", ";", "debug_rtx", "(", "insn", ")", ";", "fprintf", "(", "stderr", ",", "\"\\033[0m\"", ")", ";", "if", "(", "SET_P", "(", "pattern", ")", ")", "record_content", "(", "SET_DEST", "(", "pattern", ")", ",", "SET_SRC", "(", "pattern", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "recog_data", ".", "n_operands", ";", "i", "++", ")", "if", "(", "GET_CODE", "(", "OP", "(", "i", ")", ")", "==", "MEM", "&&", "GET_MODE", "(", "XEXP", "(", "OP", "(", "i", ")", ",", "0", ")", ")", "==", "SImode", "&&", "GET_CODE", "(", "XEXP", "(", "OP", "(", "i", ")", ",", "0", ")", ")", "!=", "UNSPEC", ")", "goto", "not_ok", ";", "return", "true", ";", "}", "}", "not_ok", ":", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "cfun", "->", "machine", "->", "virt_insns_ok", "=", "1", ";", "if", "(", "recog", "(", "pattern", ",", "insn", ",", "0", ")", ">", "-", "1", ")", "{", "extract_insn", "(", "insn", ")", ";", "if", "(", "constrain_operands", "(", "0", ",", "get_preferred_alternatives", "(", "insn", ")", ")", ")", "{", "cfun", "->", "machine", "->", "virt_insns_ok", "=", "0", ";", "return", "false", ";", "}", "}", "fprintf", "(", "stderr", ",", "\"\\033[41;30m Unrecognized *virtual* insn \\033[0m\\n\"", ")", ";", "debug_rtx", "(", "insn", ")", ";", "gcc_unreachable", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Rescans", "an", "insn", "to", "see", "if", "it", "'s", "recognized", "again", ".", "This", "is", "done", "carefully", "to", "ensure", "that", "all", "the", "constraint", "information", "is", "accurate", "for", "the", "newly", "matched", "insn", "." ]

[ "rl78", "1", "0", "1", "1", "\"\\033[32m\"", "\"\\033[0m\"", "0", "0", "0", "1", "1", "0", "1", "0", "0", "\"\\033[41;30m Unrecognized *virtual* insn \\033[0m\\n\"" ]

[]

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

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

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

[]

[ "<s>", "void", "ARCRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineOperand", "&", "FrameOp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "int", "FrameIndex", "=", "FrameOp", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "ARCInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "ARCSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "ARCFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "int", "ObjSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "int", "StackSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "int", "LocalFrameSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getLocalFrameSize", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"<--------->\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "MI", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"ObjSize : \"", "<<", "ObjSize", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"FrameOffset : \"", "<<", "Offset", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"StackSize : \"", "<<", "StackSize", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"LocalFrameSize : \"", "<<", "LocalFrameSize", "<<", "\"\\n\"", ")", ";", "(", "void", ")", "LocalFrameSize", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "{", "Register", "FrameReg", "=", "getFrameRegister", "(", "MF", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Offset : \"", "<<", "Offset", "<<", "\"\\n\"", "<<", "\"<--------->\\n\"", ")", ";", "Register", "Reg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "contains", "(", "Reg", ")", "&&", "\"Unexpected register operand\"", ")", ";", "if", "(", "!", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "Offset", "=", "StackSize", "+", "Offset", ";", "if", "(", "FrameIndex", ">=", "0", ")", "assert", "(", "(", "Offset", ">=", "0", "&&", "Offset", "<", "StackSize", ")", "&&", "\"SP Offset not in bounds.\"", ")", ";", "}", "else", "{", "if", "(", "FrameIndex", ">=", "0", ")", "{", "assert", "(", "(", "Offset", "<", "0", "&&", "-", "Offset", "<=", "StackSize", ")", "&&", "\"FP Offset not in bounds.\"", ")", ";", "}", "}", "ReplaceFrameIndex", "(", "II", ",", "TII", ",", "Reg", ",", "getFrameRegister", "(", "MF", ")", ",", "Offset", ",", "StackSize", ",", "ObjSize", ",", "RS", ",", "SPAdj", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "0", "\"Unexpected\"", "ARC", "ARC", "ARC", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"ObjSize : \"", "\"\\n\"", "\"FrameOffset : \"", "\"\\n\"", "\"StackSize : \"", "\"\\n\"", "\"LocalFrameSize : \"", "\"\\n\"", "1", "1", "\"Offset : \"", "\"\\n\"", "\"<--------->\\n\"", "0", "ARC::GPR32RegClass", "\"Unexpected register operand\"", "0", "0", "\"SP Offset not in bounds.\"", "0", "0", "\"FP Offset not in bounds.\"" ]

[]

[ "<s>", "bool", "ARMSubtarget", "::", "enablePostRAMachineScheduler", "(", ")", "const", "{", "if", "(", "!", "enableMachineScheduler", "(", ")", ")", "return", "false", ";", "if", "(", "disablePostRAScheduler", "(", ")", ")", "return", "false", ";", "return", "!", "isThumb1Only", "(", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "subtarget", "should", "run", "a", "machine", "scheduler", "after", "register", "allocation", "." ]

[ "ARM", "ARM" ]

[]

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

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

[ "OR1K", "OR1K", "OR1K" ]

[]

[ "<s>", "const", "char", "*", "riscv_output_gpr_save", "(", "unsigned", "mask", ")", "{", "static", "char", "s", "[", "32", "]", ";", "unsigned", "n", "=", "riscv_save_libcall_count", "(", "mask", ")", ";", "ssize_t", "bytes", "=", "snprintf", "(", "s", ",", "sizeof", "(", "s", ")", ",", "\"call\\tt0,__riscv_save_%u\"", ",", "n", ")", ";", "gcc_assert", "(", "(", "size_t", ")", "bytes", "<", "sizeof", "(", "s", ")", ")", ";", "return", "s", ";", "}", "</s>" ]

[ "Return", "the", "code", "to", "invoke", "the", "GPR", "save", "routine", "." ]

[ "riscv", "32", "\"call\\tt0,__riscv_save_%u\"" ]

[]

[ "<s>", "bool", "hasReadVCCZBug", "(", ")", "const", "{", "return", "getGeneration", "(", ")", "<=", "SEA_ISLANDS", ";", "}", "</s>" ]

[ "Extra", "wait", "hazard", "is", "needed", "in", "some", "cases", "before", "s_cbranch_vccnz/s_cbranch_vccz", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "bool", "s390_bb_fallthru_entry_likely", "(", "basic_block", "bb", ")", "{", "edge", "e", ",", "fallthru_edge", ";", "edge_iterator", "ei", ";", "if", "(", "!", "bb", ")", "return", "false", ";", "fallthru_edge", "=", "find_fallthru_edge", "(", "bb", "->", "preds", ")", ";", "if", "(", "!", "fallthru_edge", ")", "return", "false", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "bb", "->", "preds", ")", "if", "(", "e", "!=", "fallthru_edge", "&&", "e", "->", "probability", ">=", "profile_probability", "::", "likely", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "TRUE", "if", "BB", "is", "entered", "via", "a", "fallthru", "edge", "and", "all", "other", "incoming", "edges", "are", "less", "than", "unlikely", "." ]

[ "s390" ]

[]

[ "<s>", "bool", "csky_symbolic_address_p", "(", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "1", ";", "case", "CONST", ":", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "return", "(", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "LABEL_REF", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "an", "address", "form", "involving", "a", "symbol", "or", "label", "ref", "." ]

[ "csky", "1", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "static", "rtx", "frv_expand_binopimm_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "arglist", ",", "rtx", "target", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "rtx", "op1", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "if", "(", "!", "frv_check_constant_argument", "(", "icode", ",", "2", ",", "op1", ")", ")", "return", "NULL_RTX", ";", "target", "=", "frv_legitimize_target", "(", "icode", ",", "target", ")", ";", "op0", "=", "frv_legitimize_argument", "(", "icode", ",", "1", ",", "op0", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ",", "op1", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "builtins", "that", "take", "two", "operands", "and", "the", "second", "is", "immediate", "." ]

[ "frv", "2", "1" ]

[]

[ "<s>", "LLVM_DUMP_METHOD", "void", "dump", "(", "const", "MachineRegisterInfo", "*", "MRI", ")", "const", "{", "dbgs", "(", ")", "<<", "\"Registers: \"", ";", "bool", "First", "=", "true", ";", "for", "(", "unsigned", "Reg", ":", "Edges", ")", "{", "if", "(", "!", "First", ")", "dbgs", "(", ")", "<<", "\", \"", ";", "First", "=", "false", ";", "dbgs", "(", ")", "<<", "printReg", "(", "Reg", ",", "MRI", "->", "getTargetRegisterInfo", "(", ")", ",", "0", ",", "MRI", ")", ";", "}", "dbgs", "(", ")", "<<", "\"\\n\"", "<<", "\"Instructions:\"", ";", "for", "(", "MachineInstr", "*", "MI", ":", "Instrs", ")", "{", "dbgs", "(", ")", "<<", "\"\\n \"", ";", "MI", "->", "print", "(", "dbgs", "(", ")", ")", ";", "}", "dbgs", "(", ")", "<<", "\"\\n\"", ";", "}", "</s>" ]

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

[ "X86", "\"Registers: \"", "\", \"", "0", "\"\\n\"", "\"Instructions:\"", "\"\\n \"", "\"\\n\"" ]

[]

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

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

[ "Mips" ]

[]

[ "<s>", "static", "rtx", "sh_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", ",", "machine_mode", "mode", ")", "{", "if", "(", "flag_pic", ")", "x", "=", "legitimize_pic_address", "(", "oldx", ",", "mode", ",", "NULL_RTX", ")", ";", "if", "(", "TARGET_SHMEDIA", ")", "return", "x", ";", "if", "(", "(", "(", "TARGET_SH4", "||", "TARGET_SH2A_DOUBLE", ")", "&&", "mode", "==", "DFmode", ")", "||", "(", "TARGET_SH2E", "&&", "mode", "==", "SFmode", ")", ")", "return", "x", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "BASE_REGISTER_RTX_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "{", "struct", "disp_adjust", "adj", "=", "sh_find_mov_disp_adjust", "(", "mode", ",", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "if", "(", "adj", ".", "offset_adjust", "!=", "NULL_RTX", "&&", "adj", ".", "mov_disp", "!=", "NULL_RTX", ")", "{", "rtx", "sum", "=", "expand_binop", "(", "Pmode", ",", "add_optab", ",", "XEXP", "(", "x", ",", "0", ")", ",", "adj", ".", "offset_adjust", ",", "NULL_RTX", ",", "0", ",", "OPTAB_LIB_WIDEN", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "sum", ",", "adj", ".", "mov_disp", ")", ";", "}", "}", "return", "x", ";", "}", "</s>" ]

[ "Try", "to", "modify", "an", "illegitimate", "address", "and", "make", "it", "legitimate", ".", "If", "we", "find", "one", ",", "return", "the", "new", ",", "valid", "address", ".", "Otherwise", ",", "return", "the", "original", "address", "." ]

[ "sh", "1", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "void", "output_reg", "(", "FILE", "*", "file", ",", "unsigned", "regno", ",", "machine_mode", "inner_mode", ",", "int", "subreg_offset", "=", "-", "1", ")", "{", "if", "(", "inner_mode", "==", "VOIDmode", ")", "{", "if", "(", "HARD_REGISTER_NUM_P", "(", "regno", ")", ")", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "regno", "]", ")", ";", "else", "fprintf", "(", "file", ",", "\"%%r%d\"", ",", "regno", ")", ";", "}", "else", "if", "(", "subreg_offset", ">=", "0", ")", "{", "output_reg", "(", "file", ",", "regno", ",", "VOIDmode", ")", ";", "fprintf", "(", "file", ",", "\"$%d\"", ",", "subreg_offset", ")", ";", "}", "else", "{", "if", "(", "subreg_offset", "==", "-", "1", ")", "fprintf", "(", "file", ",", "\"{\"", ")", ";", "output_reg", "(", "file", ",", "regno", ",", "inner_mode", ",", "GET_MODE_SIZE", "(", "inner_mode", ")", ")", ";", "fprintf", "(", "file", ",", "\",\"", ")", ";", "output_reg", "(", "file", ",", "regno", ",", "inner_mode", ",", "0", ")", ";", "if", "(", "subreg_offset", "==", "-", "1", ")", "fprintf", "(", "file", ",", "\"}\"", ")", ";", "}", "}", "</s>" ]

[ "Output", "a", "register", ",", "subreg", ",", "or", "register", "pair", "(", "with", "optional", "enclosing", "braces", ")", "." ]

[ "nvptx", "1", "\"%s\"", "\"%%r%d\"", "0", "\"$%d\"", "1", "\"{\"", "\",\"", "0", "1", "\"}\"" ]

[]

[ "<s>", "SDValue", "PIC16TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "unsigned", "NumArgVals", "=", "Ins", ".", "size", "(", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "std", "::", "string", "FuncName", "=", "F", "->", "getName", "(", ")", ";", "ResetTmpOffsetMap", "(", "DAG", ")", ";", "InitReservedFrameCount", "(", "F", ",", "DAG", ")", ";", "const", "char", "*", "tmpName", "=", "ESNames", "::", "createESName", "(", "PAN", "::", "getArgsLabel", "(", "FuncName", ")", ")", ";", "SDValue", "ES", "=", "DAG", ".", "getTargetExternalSymbol", "(", "tmpName", ",", "MVT", "::", "i8", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "i8", ",", "MVT", "::", "Other", ")", ";", "SDValue", "BS", "=", "DAG", ".", "getConstant", "(", "1", ",", "MVT", "::", "i8", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumArgVals", ";", "++", "i", ")", "{", "SDValue", "Offset", "=", "DAG", ".", "getConstant", "(", "i", ",", "MVT", "::", "i8", ")", ";", "SDValue", "PICLoad", "=", "DAG", ".", "getNode", "(", "PIC16ISD", "::", "PIC16LdArg", ",", "dl", ",", "VTs", ",", "Chain", ",", "ES", ",", "BS", ",", "Offset", ")", ";", "Chain", "=", "getChain", "(", "PICLoad", ")", ";", "InVals", ".", "push_back", "(", "PICLoad", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "ISD::InputArg", "MVT::i8", "MVT::i8", "MVT::Other", "1", "MVT::i8", "0", "MVT::i8", "PIC16ISD::PIC16LdArg" ]

[]

[ "<s>", "uint32_t", "fpDenormModeSPValue", "(", ")", "const", "{", "if", "(", "FP32InputDenormals", "&&", "FP32OutputDenormals", ")", "return", "FP_DENORM_FLUSH_NONE", ";", "if", "(", "FP32InputDenormals", ")", "return", "FP_DENORM_FLUSH_OUT", ";", "if", "(", "FP32OutputDenormals", ")", "return", "FP_DENORM_FLUSH_IN", ";", "return", "FP_DENORM_FLUSH_IN_FLUSH_OUT", ";", "}", "</s>" ]

[ "Get", "the", "encoding", "value", "for", "the", "FP_DENORM", "bits", "of", "the", "mode", "register", "for", "the", "FP32", "denormal", "mode", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "int", "eligible_for_return_delay", "(", "rtx_insn", "*", "trial", ")", "{", "int", "regno", ";", "rtx", "pat", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "return", "0", ";", "if", "(", "get_attr_in_branch_delay", "(", "trial", ")", "==", "IN_BRANCH_DELAY_FALSE", ")", "return", "0", ";", "if", "(", "sparc_leaf_function_p", "||", "TARGET_FLAT", ")", "return", "1", ";", "if", "(", "!", "NONJUMP_INSN_P", "(", "trial", ")", ")", "return", "0", ";", "pat", "=", "PATTERN", "(", "trial", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "{", "int", "i", ";", "if", "(", "!", "TARGET_V9", ")", "return", "0", ";", "for", "(", "i", "=", "XVECLEN", "(", "pat", ",", "0", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "rtx", "expr", "=", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "expr", ")", "!=", "SET", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "expr", ")", ")", "!=", "REG", ")", "return", "0", ";", "regno", "=", "REGNO", "(", "SET_DEST", "(", "expr", ")", ")", ";", "if", "(", "regno", ">=", "8", "&&", "regno", "<", "24", ")", "return", "0", ";", "}", "return", "!", "epilogue_renumber", "(", "&", "pat", ",", "1", ")", ";", "}", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "pat", ")", ")", "!=", "REG", ")", "return", "0", ";", "regno", "=", "REGNO", "(", "SET_DEST", "(", "pat", ")", ")", ";", "if", "(", "regno", ">=", "8", "&&", "regno", "<", "24", ")", "return", "0", ";", "if", "(", "!", "SPARC_INT_REG_P", "(", "regno", ")", ")", "return", "TARGET_V9", "&&", "!", "epilogue_renumber", "(", "&", "pat", ",", "1", ")", ";", "return", "eligible_for_restore_insn", "(", "trial", ",", "true", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "TRIAL", "can", "go", "into", "the", "function", "return", "'s", "delay", "slot", "." ]

[ "sparc", "0", "0", "1", "0", "0", "0", "1", "0", "0", "0", "0", "8", "24", "0", "1", "0", "0", "8", "24", "0", "1" ]

[]

[ "<s>", "static", "bool", "alpha_pass_by_reference", "(", "cumulative_args_t", ",", "const", "function_arg_info", "&", "arg", ")", "{", "if", "(", "arg", ".", "mode", "==", "SFmode", "||", "arg", ".", "mode", "==", "SCmode", ")", "return", "!", "arg", ".", "named", ";", "return", "arg", ".", "mode", "==", "TFmode", "||", "arg", ".", "mode", "==", "TCmode", ";", "}", "</s>" ]

[ "Return", "true", "if", "TYPE", "should", "be", "passed", "by", "invisible", "reference", "." ]

[ "alpha" ]

[]

[ "<s>", "void", "override_options", "(", ")", "{", "s390_sr_alias_set", "=", "new_alias_set", "(", ")", ";", "}", "</s>" ]

[ "Set", "global", "variables", "as", "needed", "for", "the", "options", "enabled", "." ]

[ "s390" ]

[]

[ "<s>", "static", "int", "length_fp_args", "(", "rtx", "insn", ")", "{", "int", "length", "=", "0", ";", "rtx", "link", ";", "for", "(", "link", "=", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ";", "link", ";", "link", "=", "XEXP", "(", "link", ",", "1", ")", ")", "{", "int", "arg_mode", ",", "regno", ";", "rtx", "use", "=", "XEXP", "(", "link", ",", "0", ")", ";", "if", "(", "!", "(", "GET_CODE", "(", "use", ")", "==", "USE", "&&", "GET_CODE", "(", "XEXP", "(", "use", ",", "0", ")", ")", "==", "REG", "&&", "FUNCTION_ARG_REGNO_P", "(", "REGNO", "(", "XEXP", "(", "use", ",", "0", ")", ")", ")", ")", ")", "continue", ";", "arg_mode", "=", "GET_MODE", "(", "XEXP", "(", "use", ",", "0", ")", ")", ";", "regno", "=", "REGNO", "(", "XEXP", "(", "use", ",", "0", ")", ")", ";", "if", "(", "regno", ">=", "32", "&&", "regno", "<=", "39", ")", "{", "if", "(", "arg_mode", "==", "SFmode", ")", "length", "+=", "8", ";", "else", "length", "+=", "12", ";", "}", "}", "return", "length", ";", "}", "</s>" ]

[ "Compute", "length", "of", "the", "FP", "argument", "copy", "sequence", "for", "INSN", "." ]

[ "pa", "0", "1", "0", "0", "0", "0", "0", "32", "39", "8", "12" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"WebAssembly Optimize Live Intervals\"", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"WebAssembly Optimize Live Intervals\"" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "bool", "HasAVX", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX", "(", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "V_SET0", ":", "return", "Expand2AddrUndef", "(", "MI", ",", "get", "(", "HasAVX", "?", "X86", "::", "VXORPSrr", ":", "X86", "::", "XORPSrr", ")", ")", ";", "case", "X86", "::", "TEST8ri_NOREX", ":", "MI", "->", "setDesc", "(", "get", "(", "X86", "::", "TEST8ri", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "X86", "X86", "X86", "X86::V_SET0", "X86::VXORPSrr", "X86::XORPSrr", "X86::TEST8ri_NOREX", "X86::TEST8ri" ]

[]

[ "<s>", "static", "bool", "aarch64_pass_by_reference", "(", "cumulative_args_t", "pcum", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "HOST_WIDE_INT", "size", ";", "machine_mode", "dummymode", ";", "int", "nregs", ";", "size", "=", "(", "mode", "==", "BLKmode", "&&", "type", ")", "?", "int_size_in_bytes", "(", "type", ")", ":", "(", "int", ")", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "}", "if", "(", "size", "<", "0", ")", "return", "true", ";", "if", "(", "aarch64_vfp_is_call_or_return_candidate", "(", "mode", ",", "type", ",", "&", "dummymode", ",", "&", "nregs", ",", "NULL", ")", ")", "return", "false", ";", "return", "size", ">", "2", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Implement", "TARGET_PASS_BY_REFERENCE", "." ]

[ "aarch64", "0", "2" ]

[]

[ "<s>", "static", "void", "mips_deallocate_stack", "(", "rtx", "base", ",", "rtx", "offset", ",", "HOST_WIDE_INT", "new_frame_size", ")", "{", "if", "(", "base", "==", "stack_pointer_rtx", "&&", "offset", "==", "const0_rtx", ")", "return", ";", "mips_frame_barrier", "(", ")", ";", "if", "(", "offset", "==", "const0_rtx", ")", "{", "emit_move_insn", "(", "stack_pointer_rtx", ",", "base", ")", ";", "mips_epilogue_set_cfa", "(", "stack_pointer_rtx", ",", "new_frame_size", ")", ";", "}", "else", "if", "(", "TARGET_MIPS16", "&&", "base", "!=", "stack_pointer_rtx", ")", "{", "emit_insn", "(", "gen_add3_insn", "(", "base", ",", "base", ",", "offset", ")", ")", ";", "mips_epilogue_set_cfa", "(", "base", ",", "new_frame_size", ")", ";", "emit_move_insn", "(", "stack_pointer_rtx", ",", "base", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "base", ",", "offset", ")", ")", ";", "mips_epilogue_set_cfa", "(", "stack_pointer_rtx", ",", "new_frame_size", ")", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "set", "the", "stack", "pointer", "to", "BASE", "+", "OFFSET", ",", "given", "that", "BASE", "+", "OFFSET", "is", "NEW_FRAME_SIZE", "bytes", "below", "the", "top", "of", "the", "frame", ".", "BASE", ",", "if", "not", "the", "stack", "pointer", ",", "is", "available", "as", "a", "temporary", "." ]

[ "mips" ]

[]

[ "<s>", "AMDGPUAAResult", "run", "(", "Function", "&", "F", ",", "AnalysisManager", "<", "Function", ">", "&", "AM", ")", "{", "return", "AMDGPUAAResult", "(", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ")", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

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

[]

[ "<s>", "Register", "MMIXRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "MMIX", "::", "r253", ";", "}", "</s>" ]

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

[ "MMIX", "MMIX", "MMIX::r253" ]

[]

[ "<s>", "static", "rtx", "gen_push", "(", "rtx", "arg", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "if", "(", "m", "->", "fs", ".", "cfa_reg", "==", "stack_pointer_rtx", ")", "m", "->", "fs", ".", "cfa_offset", "+=", "UNITS_PER_WORD", ";", "m", "->", "fs", ".", "sp_offset", "+=", "UNITS_PER_WORD", ";", "if", "(", "REG_P", "(", "arg", ")", "&&", "GET_MODE", "(", "arg", ")", "!=", "word_mode", ")", "arg", "=", "gen_rtx_REG", "(", "word_mode", ",", "REGNO", "(", "arg", ")", ")", ";", "return", "gen_rtx_SET", "(", "gen_rtx_MEM", "(", "word_mode", ",", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ")", ",", "arg", ")", ";", "}", "</s>" ]

[ "Code", "to", "generate", "prologue", "and", "epilogue", "sequences" ]

[ "i386" ]

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "shouldInsertExtraNopBytesForCodeAlign", "(", "const", "MCAlignFragment", "&", "AF", ",", "unsigned", "&", "Size", ")", "{", "if", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureRelax", "]", ")", "return", "false", ";", "bool", "HasStdExtC", "=", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureStdExtC", "]", ";", "unsigned", "MinNopLen", "=", "HasStdExtC", "?", "2", ":", "4", ";", "if", "(", "AF", ".", "getAlignment", "(", ")", "<=", "MinNopLen", ")", "{", "return", "false", ";", "}", "else", "{", "Size", "=", "AF", ".", "getAlignment", "(", ")", "-", "MinNopLen", ";", "return", "true", ";", "}", "}", "</s>" ]

[ "Hook", "to", "check", "if", "extra", "nop", "bytes", "must", "be", "inserted", "for", "alignment", "directive", "." ]

[ "RISCV", "RISCV", "RISCV::FeatureRelax", "RISCV::FeatureStdExtC", "2", "4" ]

[]

[ "<s>", "static", "void", "visium_option_override", "(", "void", ")", "{", "if", "(", "flag_pic", "==", "1", ")", "warning", "(", "OPT_fpic", ",", "\"-fpic is not supported\"", ")", ";", "if", "(", "flag_pic", "==", "2", ")", "warning", "(", "OPT_fPIC", ",", "\"-fPIC is not supported\"", ")", ";", "target_flags", "|=", "MASK_MCM", ";", "if", "(", "(", "target_flags_explicit", "&", "MASK_FPU", ")", "==", "0", ")", "target_flags", "|=", "MASK_FPU", ";", "if", "(", "(", "target_flags_explicit", "&", "MASK_SV_MODE", ")", "==", "0", ")", "target_flags", "|=", "MASK_SV_MODE", ";", "if", "(", "visium_cpu_and_features", "==", "PROCESSOR_GR6", ")", "{", "target_flags", "|=", "MASK_BMI", ";", "if", "(", "target_flags", "&", "MASK_FPU", ")", "target_flags", "|=", "MASK_FPU_IEEE", ";", "}", "if", "(", "!", "global_options_set", ".", "x_visium_cpu", ")", "visium_cpu", "=", "visium_cpu_and_features", ";", "if", "(", "align_functions", "==", "0", ")", "{", "if", "(", "visium_cpu", "==", "PROCESSOR_GR6", ")", "align_functions", "=", "64", ";", "else", "align_functions", "=", "256", ";", "maybe_set_param_value", "(", "PARAM_INLINE_UNIT_GROWTH", ",", "100", ",", "global_options", ".", "x_param_values", ",", "global_options_set", ".", "x_param_values", ")", ";", "}", "if", "(", "align_loops", "==", "0", ")", "{", "if", "(", "visium_cpu", "==", "PROCESSOR_GR6", ")", "align_loops", "=", "64", ";", "else", "{", "align_loops", "=", "256", ";", "align_loops_max_skip", "=", "31", ";", "}", "}", "if", "(", "align_jumps", "==", "0", ")", "{", "if", "(", "visium_cpu", "==", "PROCESSOR_GR6", ")", "align_jumps", "=", "64", ";", "else", "align_jumps", "=", "8", ";", "}", "opt_pass", "*", "visium_reorg_pass", "=", "make_pass_visium_reorg", "(", "g", ")", ";", "struct", "register_pass_info", "insert_pass_visium_reorg", "=", "{", "visium_reorg_pass", ",", "\"dbr\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "register_pass", "(", "&", "insert_pass_visium_reorg", ")", ";", "}", "</s>" ]

[ "Options", "override", "for", "Visium", "." ]

[ "visium", "1", "\"-fpic is not supported\"", "2", "\"-fPIC is not supported\"", "0", "0", "0", "64", "256", "100", "0", "64", "256", "31", "0", "64", "8", "\"dbr\"", "1" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "getNumRegistersForCallingConv", "(", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", "==", "MVT", "::", "v32i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "return", "1", ";", "return", "TargetLowering", "::", "getNumRegistersForCallingConv", "(", "Context", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "MVT::v32i1", "1" ]

[]

[ "<s>", "bool", "AArch64BranchRelaxation", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "MF", "=", "&", "mf", ";", "if", "(", "!", "BranchRelaxation", ")", "return", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64BranchRelaxation *****\\n\"", ")", ";", "TII", "=", "(", "const", "AArch64InstrInfo", "*", ")", "MF", "->", "getTarget", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "scanFunction", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" Basic blocks before relaxation\\n\"", ")", ";", "DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "bool", "MadeChange", "=", "false", ";", "while", "(", "relaxBranchInstructions", "(", ")", ")", "MadeChange", "=", "true", ";", "verify", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" Basic blocks after relaxation\\n\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "'\\n'", ";", "dumpBBs", "(", ")", ")", ";", "BlockInfo", ".", "clear", "(", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"***** AArch64BranchRelaxation *****\\n\"", "AArch64", "\" Basic blocks before relaxation\\n\"", "\" Basic blocks after relaxation\\n\"" ]

[]

[ "<s>", "int", "nds32_adjust_insn_length", "(", "rtx_insn", "*", "insn", ",", "int", "length", ")", "{", "rtx", "src", ",", "dst", ";", "switch", "(", "recog_memoized", "(", "insn", ")", ")", "{", "case", "CODE_FOR_move_df", ":", "case", "CODE_FOR_move_di", ":", "src", "=", "XEXP", "(", "PATTERN", "(", "insn", ")", ",", "1", ")", ";", "dst", "=", "XEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ")", ";", "if", "(", "REG_P", "(", "src", ")", "&&", "REG_P", "(", "dst", ")", "&&", "(", "REGNO", "(", "src", ")", "%", "2", ")", "==", "0", "&&", "(", "REGNO", "(", "dst", ")", "%", "2", ")", "==", "0", ")", "length", "=", "2", ";", "break", ";", "default", ":", "break", ";", "}", "return", "length", ";", "}", "</s>" ]

[ "Computing", "the", "Length", "of", "an", "Insn", ".", "Modifies", "the", "length", "assigned", "to", "instruction", "INSN", ".", "LEN", "is", "the", "initially", "computed", "length", "of", "the", "insn", "." ]

[ "nds32", "1", "0", "2", "0", "2", "0", "2" ]

[]

[ "<s>", "MVT", "AMDGPUTargetLowering", "::", "getVectorIdxTy", "(", "const", "DataLayout", "&", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Returns", "the", "type", "to", "be", "used", "for", "the", "index", "operand", "of", ":", "ISD", ":", ":INSERT_VECTOR_ELT", ",", "ISD", ":", ":EXTRACT_VECTOR_ELT", ",", "ISD", ":", ":INSERT_SUBVECTOR", ",", "and", "ISD", ":", ":EXTRACT_SUBVECTOR", "." ]

[ "AMDGPU", "AMDGPU", "MVT::i32" ]

[]

[ "<s>", "bool", "MSP430TargetLowering", "::", "isTruncateFree", "(", "const", "Type", "*", "Ty1", ",", "const", "Type", "*", "Ty2", ")", "const", "{", "if", "(", "!", "Ty1", "->", "isIntegerTy", "(", ")", "||", "!", "Ty2", "->", "isIntegerTy", "(", ")", ")", "return", "false", ";", "return", "(", "Ty1", "->", "getPrimitiveSizeInBits", "(", ")", ">", "Ty2", "->", "getPrimitiveSizeInBits", "(", ")", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430" ]

[]

[ "<s>", "unsigned", "getCSRFirstUseCost", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "100", ";", "}", "</s>" ]

[ "Allow", "the", "target", "to", "override", "the", "cost", "of", "using", "a", "callee-saved", "register", "for", "the", "first", "time", "." ]

[ "AMDGPU", "100" ]

[]

[ "<s>", "void", "R600PassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createR600VectorRegMerger", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "tree", "altivec_build_resolved_builtin", "(", "tree", "*", "args", ",", "int", "n", ",", "const", "struct", "altivec_builtin_types", "*", "desc", ")", "{", "tree", "impl_fndecl", "=", "rs6000_builtin_decls", "[", "desc", "->", "overloaded_code", "]", ";", "tree", "ret_type", "=", "rs6000_builtin_type", "(", "desc", "->", "ret_type", ")", ";", "tree", "argtypes", "=", "TYPE_ARG_TYPES", "(", "TREE_TYPE", "(", "impl_fndecl", ")", ")", ";", "tree", "arglist", "=", "NULL_TREE", ",", "arg_type", "[", "3", "]", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "arg_type", "[", "i", "]", "=", "TREE_VALUE", "(", "argtypes", ")", ",", "argtypes", "=", "TREE_CHAIN", "(", "argtypes", ")", ";", "if", "(", "desc", "->", "code", "==", "ALTIVEC_BUILTIN_VCMPGE_P", "&&", "desc", "->", "overloaded_code", "!=", "ALTIVEC_BUILTIN_VCMPGEFP_P", ")", "{", "tree", "t", ";", "t", "=", "args", "[", "2", "]", ",", "args", "[", "2", "]", "=", "args", "[", "1", "]", ",", "args", "[", "1", "]", "=", "t", ";", "t", "=", "arg_type", "[", "2", "]", ",", "arg_type", "[", "2", "]", "=", "arg_type", "[", "1", "]", ",", "arg_type", "[", "1", "]", "=", "t", ";", "args", "[", "0", "]", "=", "fold_build2", "(", "BIT_XOR_EXPR", ",", "TREE_TYPE", "(", "args", "[", "0", "]", ")", ",", "args", "[", "0", "]", ",", "build_int_cst", "(", "NULL_TREE", ",", "2", ")", ")", ";", "}", "while", "(", "--", "n", ">=", "0", ")", "arglist", "=", "tree_cons", "(", "NULL_TREE", ",", "fold_convert", "(", "arg_type", "[", "n", "]", ",", "args", "[", "n", "]", ")", ",", "arglist", ")", ";", "return", "fold_convert", "(", "ret_type", ",", "build_function_call_expr", "(", "impl_fndecl", ",", "arglist", ")", ")", ";", "}", "</s>" ]

[ "Build", "a", "tree", "for", "a", "function", "call", "to", "an", "Altivec", "non-overloaded", "builtin", ".", "The", "overloaded", "builtin", "that", "matched", "the", "types", "and", "args", "is", "described", "by", "DESC", ".", "The", "N", "arguments", "are", "given", "in", "ARGS", ",", "respectively", ".", "Actually", "the", "only", "thing", "it", "does", "is", "calling", "fold_convert", "on", "ARGS", ",", "with", "a", "small", "exception", "for", "vec_", "{", "all", ",", "any", "}", "_", "{", "ge", ",", "le", "}", "predicates", "." ]

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

[]

[ "<s>", "InstructionCost", "ARMTTIImpl", "::", "getArithmeticReductionCost", "(", "unsigned", "Opcode", ",", "VectorType", "*", "ValTy", ",", "Optional", "<", "FastMathFlags", ">", "FMF", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "if", "(", "TTI", "::", "requiresOrderedReduction", "(", "FMF", ")", ")", "return", "BaseT", "::", "getArithmeticReductionCost", "(", "Opcode", ",", "ValTy", ",", "FMF", ",", "CostKind", ")", ";", "EVT", "ValVT", "=", "TLI", "->", "getValueType", "(", "DL", ",", "ValTy", ")", ";", "int", "ISD", "=", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", ";", "if", "(", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", "||", "!", "ValVT", ".", "isSimple", "(", ")", "||", "ISD", "!=", "ISD", "::", "ADD", ")", "return", "BaseT", "::", "getArithmeticReductionCost", "(", "Opcode", ",", "ValTy", ",", "FMF", ",", "CostKind", ")", ";", "std", "::", "pair", "<", "InstructionCost", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "ValTy", ")", ";", "static", "const", "CostTblEntry", "CostTblAdd", "[", "]", "{", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v16i8", ",", "1", "}", ",", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v8i16", ",", "1", "}", ",", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v4i32", ",", "1", "}", ",", "}", ";", "if", "(", "const", "auto", "*", "Entry", "=", "CostTableLookup", "(", "CostTblAdd", ",", "ISD", ",", "LT", ".", "second", ")", ")", "return", "Entry", "->", "Cost", "*", "ST", "->", "getMVEVectorCostFactor", "(", "CostKind", ")", "*", "LT", ".", "first", ";", "return", "BaseT", "::", "getArithmeticReductionCost", "(", "Opcode", ",", "ValTy", ",", "FMF", ",", "CostKind", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "vector", "reduction", "intrinsics", "." ]

[ "ARM", "ARM", "ISD::ADD", "ISD::ADD", "MVT::v16i8", "1", "ISD::ADD", "MVT::v8i16", "1", "ISD::ADD", "MVT::v4i32", "1" ]

[]

[ "<s>", "unsigned", "TOYMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "return", "CTX", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"unknown operand kind in printOperand\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "MCExpr", "::", "ExprKind", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "if", "(", "Kind", "==", "MCExpr", "::", "Binary", ")", "{", "Expr", "=", "static_cast", "<", "const", "MCBinaryExpr", "*", ">", "(", "Expr", ")", "->", "getLHS", "(", ")", ";", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "}", "assert", "(", "Kind", "==", "MCExpr", "::", "SymbolRef", ")", ";", "unsigned", "FixupKind", ";", "switch", "(", "cast", "<", "MCSymbolRefExpr", ">", "(", "Expr", ")", "->", "getKind", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown fixup kind!\"", ")", ";", "case", "MCSymbolRefExpr", "::", "VK_TOY_LO", ":", "{", "FixupKind", "=", "TOY", "::", "fixup_toy_mov_lo16_pcrel", ";", "break", ";", "}", "case", "MCSymbolRefExpr", "::", "VK_TOY_HI", ":", "{", "FixupKind", "=", "TOY", "::", "fixup_toy_mov_hi16_pcrel", ";", "break", ";", "}", "}", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "MO", ".", "getExpr", "(", ")", ",", "MCFixupKind", "(", "FixupKind", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "\"unknown operand kind in printOperand\"", "\"Unknown fixup kind!\"", "TOY", "TOY::fixup_toy_mov_lo16_pcrel", "TOY", "TOY::fixup_toy_mov_hi16_pcrel", "0", "0" ]

[]

[ "<s>", "SDValue", "CSKYTargetLowering", "::", "getTargetNode", "(", "BlockAddressSDNode", "*", "N", ",", "SDLoc", "DL", ",", "EVT", "Ty", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Flags", ")", "const", "{", "return", "DAG", ".", "getTargetBlockAddress", "(", "N", "->", "getBlockAddress", "(", ")", ",", "Ty", ",", "N", "->", "getOffset", "(", ")", ",", "Flags", ")", ";", "}", "</s>" ]

[ "Retrieve", "the", "target", "node", "this", "edge", "connects", "to", "." ]

[ "CSKY", "CSKY" ]

[]

[ "<s>", "rtx", "xtensa_copy_incoming_a7", "(", "rtx", "opnd", ")", "{", "rtx", "entry_insns", "=", "0", ";", "rtx", "reg", ",", "tmp", ";", "machine_mode", "mode", ";", "if", "(", "!", "cfun", "->", "machine", "->", "need_a7_copy", ")", "return", "opnd", ";", "gcc_assert", "(", "!", "cfun", "->", "machine", "->", "set_frame_ptr_insn", ")", ";", "mode", "=", "GET_MODE", "(", "opnd", ")", ";", "reg", "=", "opnd", ";", "if", "(", "GET_CODE", "(", "reg", ")", "==", "SUBREG", ")", "{", "gcc_assert", "(", "SUBREG_BYTE", "(", "reg", ")", "==", "0", ")", ";", "reg", "=", "SUBREG_REG", "(", "reg", ")", ";", "}", "if", "(", "GET_CODE", "(", "reg", ")", "!=", "REG", "||", "REGNO", "(", "reg", ")", ">", "A7_REG", "||", "REGNO", "(", "reg", ")", "+", "HARD_REGNO_NREGS", "(", "A7_REG", ",", "mode", ")", "<=", "A7_REG", ")", "return", "opnd", ";", "gcc_assert", "(", "REGNO", "(", "reg", ")", "+", "HARD_REGNO_NREGS", "(", "A7_REG", ",", "mode", ")", "-", "1", "==", "A7_REG", ")", ";", "cfun", "->", "machine", "->", "need_a7_copy", "=", "false", ";", "start_sequence", "(", ")", ";", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "switch", "(", "mode", ")", "{", "case", "DFmode", ":", "case", "DImode", ":", "emit_insn", "(", "gen_movsi_internal", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "tmp", ",", "4", ")", ",", "gen_raw_REG", "(", "SImode", ",", "A7_REG", ")", ")", ")", ";", "break", ";", "case", "SFmode", ":", "emit_insn", "(", "gen_movsf_internal", "(", "tmp", ",", "gen_raw_REG", "(", "mode", ",", "A7_REG", ")", ")", ")", ";", "break", ";", "case", "SImode", ":", "emit_insn", "(", "gen_movsi_internal", "(", "tmp", ",", "gen_raw_REG", "(", "mode", ",", "A7_REG", ")", ")", ")", ";", "break", ";", "case", "HImode", ":", "emit_insn", "(", "gen_movhi_internal", "(", "tmp", ",", "gen_raw_REG", "(", "mode", ",", "A7_REG", ")", ")", ")", ";", "break", ";", "case", "QImode", ":", "emit_insn", "(", "gen_movqi_internal", "(", "tmp", ",", "gen_raw_REG", "(", "mode", ",", "A7_REG", ")", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "cfun", "->", "machine", "->", "set_frame_ptr_insn", "=", "emit_insn", "(", "gen_set_frame_ptr", "(", ")", ")", ";", "if", "(", "mode", "==", "DFmode", "||", "mode", "==", "DImode", ")", "emit_insn", "(", "gen_movsi_internal", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "tmp", ",", "0", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "A7_REG", "-", "1", ")", ")", ")", ";", "entry_insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "if", "(", "cfun", "->", "machine", "->", "vararg_a7", ")", "{", "cfun", "->", "machine", "->", "vararg_a7_copy", "=", "entry_insns", ";", "}", "else", "{", "push_topmost_sequence", "(", ")", ";", "emit_insn_after", "(", "entry_insns", ",", "get_insns", "(", ")", ")", ";", "pop_topmost_sequence", "(", ")", ";", "}", "return", "tmp", ";", "}", "</s>" ]

[ "Check", "if", "an", "incoming", "argument", "in", "a7", "is", "expected", "to", "be", "used", "soon", "and", "if", "OPND", "is", "a", "register", "or", "register", "pair", "that", "includes", "a7", ".", "If", "so", ",", "create", "a", "new", "pseudo", "and", "copy", "a7", "into", "that", "pseudo", "at", "the", "very", "beginning", "of", "the", "function", ",", "followed", "by", "the", "special", "``", "set_frame_ptr", "''", "unspec_volatile", "insn", ".", "The", "return", "value", "is", "either", "the", "original", "operand", ",", "if", "it", "is", "not", "a7", ",", "or", "the", "new", "pseudo", "containing", "a", "copy", "of", "the", "incoming", "argument", ".", "This", "is", "necessary", "because", "the", "register", "allocator", "will", "ignore", "conflicts", "with", "a7", "and", "may", "either", "assign", "some", "other", "pseudo", "to", "a7", "or", "use", "a7", "as", "the", "hard_frame_pointer", ",", "clobbering", "the", "incoming", "argument", "in", "a7", ".", "By", "copying", "the", "argument", "out", "of", "a7", "as", "the", "very", "first", "thing", ",", "and", "then", "immediately", "following", "that", "with", "an", "unspec_volatile", "to", "keep", "the", "scheduler", "away", ",", "we", "should", "avoid", "any", "problems", ".", "Putting", "the", "set_frame_ptr", "insn", "at", "the", "beginning", ",", "with", "only", "the", "a7", "copy", "before", "it", ",", "also", "makes", "it", "easier", "for", "the", "prologue", "expander", "to", "initialize", "the", "frame", "pointer", "after", "the", "a7", "copy", "and", "to", "fix", "up", "the", "a7", "copy", "to", "use", "the", "stack", "pointer", "instead", "of", "the", "frame", "pointer", "." ]

[ "xtensa", "0", "0", "1", "4", "0", "1" ]

[]

[ "<s>", "int", "ep_memory_operand", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "int", "unsigned_load", ")", "{", "rtx", "addr", ",", "op0", ",", "op1", ";", "int", "max_offset", ";", "int", "mask", ";", "if", "(", "!", "TARGET_EP", ")", "return", "FALSE", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "FALSE", ";", "max_offset", "=", "ep_memory_offset", "(", "mode", ",", "unsigned_load", ")", ";", "mask", "=", "GET_MODE_SIZE", "(", "mode", ")", "-", "1", ";", "addr", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "CONST", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "default", ":", "break", ";", "case", "SYMBOL_REF", ":", "return", "SYMBOL_REF_TDA_P", "(", "addr", ")", ";", "case", "REG", ":", "return", "REGNO", "(", "addr", ")", "==", "EP_REGNUM", ";", "case", "PLUS", ":", "op0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "op1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "op1", ")", "<", "max_offset", "&&", "INTVAL", "(", "op1", ")", ">=", "0", "&&", "(", "INTVAL", "(", "op1", ")", "&", "mask", ")", "==", "0", ")", "{", "if", "(", "GET_CODE", "(", "op0", ")", "==", "REG", "&&", "REGNO", "(", "op0", ")", "==", "EP_REGNUM", ")", "return", "TRUE", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TDA_P", "(", "op0", ")", ")", "return", "TRUE", ";", "}", "break", ";", "}", "return", "FALSE", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "valid", "short", "EP", "memory", "reference" ]

[ "v850", "1", "0", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "void", "AArch64MCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "verifyInstructionPredicates", "(", "MI", ",", "computeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "TLSDESCCALL", ")", "{", "MCFixupKind", "Fixup", "=", "MCFixupKind", "(", "AArch64", "::", "fixup_aarch64_tlsdesc_call", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "MI", ".", "getOperand", "(", "0", ")", ".", "getExpr", "(", ")", ",", "Fixup", ")", ")", ";", "return", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "CompilerBarrier", "||", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "SPACE", ")", "{", "return", ";", "}", "uint64_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "OS", ",", "Binary", ",", "support", "::", "little", ")", ";", "++", "MCNumEmitted", ";", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "AArch64", "AArch64", "AArch64::TLSDESCCALL", "AArch64::fixup_aarch64_tlsdesc_call", "0", "0", "AArch64::CompilerBarrier", "AArch64::SPACE", "support::endian", "support::little" ]

[]

[ "<s>", "bool", "R600Packetizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "TargetInstrInfo", "*", "TII", "=", "Fn", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineLoopInfo", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineDominatorTree", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "R600PacketizerList", "Packetizer", "(", "Fn", ",", "MLI", ",", "MDT", ")", ";", "assert", "(", "Packetizer", ".", "getResourceTracker", "(", ")", "&&", "\"Empty DFA table!\"", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "MachineBasicBlock", "::", "iterator", "End", "=", "MBB", "->", "end", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MI", "=", "MBB", "->", "begin", "(", ")", ";", "while", "(", "MI", "!=", "End", ")", "{", "if", "(", "MI", "->", "isKill", "(", ")", "||", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", "||", "(", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "CF_ALU", "&&", "!", "MI", "->", "getOperand", "(", "8", ")", ".", "getImm", "(", ")", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "DeleteMI", "=", "MI", ";", "++", "MI", ";", "MBB", "->", "erase", "(", "DeleteMI", ")", ";", "End", "=", "MBB", "->", "end", "(", ")", ";", "continue", ";", "}", "++", "MI", ";", "}", "}", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "unsigned", "RemainingCount", "=", "MBB", "->", "size", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "RegionEnd", "=", "MBB", "->", "end", "(", ")", ";", "RegionEnd", "!=", "MBB", "->", "begin", "(", ")", ";", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "RegionEnd", ";", "for", "(", ";", "I", "!=", "MBB", "->", "begin", "(", ")", ";", "--", "I", ",", "--", "RemainingCount", ")", "{", "if", "(", "TII", "->", "isSchedulingBoundary", "(", "std", "::", "prev", "(", "I", ")", ",", "MBB", ",", "Fn", ")", ")", "break", ";", "}", "I", "=", "MBB", "->", "begin", "(", ")", ";", "if", "(", "I", "==", "RegionEnd", ")", "{", "RegionEnd", "=", "std", "::", "prev", "(", "RegionEnd", ")", ";", "--", "RemainingCount", ";", "continue", ";", "}", "if", "(", "I", "==", "std", "::", "prev", "(", "RegionEnd", ")", ")", "{", "RegionEnd", "=", "std", "::", "prev", "(", "RegionEnd", ")", ";", "continue", ";", "}", "Packetizer", ".", "PacketizeMIs", "(", "MBB", ",", "I", ",", "RegionEnd", ")", ";", "RegionEnd", "=", "I", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "R600", "\"Empty DFA table!\"", "8" ]

[]

[ "<s>", "static", "void", "sh_emit_storesi", "(", "rtx", "addr", ",", "HOST_WIDE_INT", "offset", ",", "rtx", "value", ")", "{", "gcc_assert", "(", "(", "offset", "&", "3", ")", "==", "0", ")", ";", "emit_move_insn", "(", "offset", "==", "0", "?", "change_address", "(", "addr", ",", "SImode", ",", "NULL_RTX", ")", ":", "adjust_address", "(", "addr", ",", "SImode", ",", "offset", ")", ",", "value", ")", ";", "}", "</s>" ]

[ "Emit", "insns", "to", "store", "a", "value", "at", "memory", "address", "+", "offset", "." ]

[ "sh", "3", "0", "0" ]

[]

[ "<s>", "static", "void", "iq2000_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "unsigned", "int", "iq2000_off", "=", "!", "cum", "->", "last_arg_fp", ";", "unsigned", "int", "iq2000_fp_off", "=", "cum", "->", "last_arg_fp", ";", "if", "(", "(", "cum", "->", "arg_words", "<", "MAX_ARGS_IN_REGISTERS", "-", "iq2000_off", ")", ")", "{", "int", "iq2000_save_gp_regs", "=", "MAX_ARGS_IN_REGISTERS", "-", "cum", "->", "arg_words", "-", "iq2000_off", ";", "int", "iq2000_save_fp_regs", "=", "(", "MAX_ARGS_IN_REGISTERS", "-", "cum", "->", "fp_arg_words", "-", "iq2000_fp_off", ")", ";", "if", "(", "iq2000_save_gp_regs", "<", "0", ")", "iq2000_save_gp_regs", "=", "0", ";", "if", "(", "iq2000_save_fp_regs", "<", "0", ")", "iq2000_save_fp_regs", "=", "0", ";", "*", "pretend_size", "=", "(", "(", "iq2000_save_gp_regs", "*", "UNITS_PER_WORD", ")", "+", "(", "iq2000_save_fp_regs", "*", "UNITS_PER_FPREG", ")", ")", ";", "if", "(", "!", "(", "no_rtl", ")", ")", "{", "if", "(", "cum", "->", "arg_words", "<", "MAX_ARGS_IN_REGISTERS", "-", "iq2000_off", ")", "{", "rtx", "ptr", ",", "mem", ";", "ptr", "=", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "-", "(", "iq2000_save_gp_regs", "*", "UNITS_PER_WORD", ")", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "ptr", ")", ";", "move_block_from_reg", "(", "cum", "->", "arg_words", "+", "GP_ARG_FIRST", "+", "iq2000_off", ",", "mem", ",", "iq2000_save_gp_regs", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_SETUP_INCOMING_VARARGS", "." ]

[ "iq2000", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "AArch64WinCOFFObjectWriter", "::", "recordRelocation", "(", "const", "MCFixup", "&", "Fixup", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Record", "a", "relocation", "entry", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "BitVector", "MINA32RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "MINA32", "::", "SP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "MINA32", "::", "PC", ")", ";", "markSuperRegs", "(", "Reserved", ",", "MINA32", "::", "R8_USER", ")", ";", "markSuperRegs", "(", "Reserved", ",", "MINA32", "::", "R9_USER", ")", ";", "markSuperRegs", "(", "Reserved", ",", "MINA32", "::", "R10_USER", ")", ";", "markSuperRegs", "(", "Reserved", ",", "MINA32", "::", "R11_USER", ")", ";", "markSuperRegs", "(", "Reserved", ",", "MINA32", "::", "R12_USER", ")", ";", "markSuperRegs", "(", "Reserved", ",", "MINA32", "::", "SP_USER", ")", ";", "markSuperRegs", "(", "Reserved", ",", "MINA32", "::", "LR_USER", ")", ";", "markSuperRegs", "(", "Reserved", ",", "MINA32", "::", "PC_USER", ")", ";", "markSuperRegs", "(", "Reserved", ",", "MINA32", "::", "MCR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "MINA32", "::", "FRET", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "MINA32", "::", "R11", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "BasePtr", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "MINA32", "MINA32", "MINA32::SP", "MINA32::PC", "MINA32::R8_USER", "MINA32::R9_USER", "MINA32::R10_USER", "MINA32::R11_USER", "MINA32::R12_USER", "MINA32::SP_USER", "MINA32::LR_USER", "MINA32::PC_USER", "MINA32::MCR", "MINA32::FRET", "MINA32::R11" ]

[]

[ "<s>", "static", "bool", "ix86_dep_by_shift_count_body", "(", "const_rtx", "set_body", ",", "const_rtx", "use_body", ")", "{", "rtx", "set_dest", ";", "rtx", "shift_rtx", ";", "int", "i", ";", "switch", "(", "GET_CODE", "(", "set_body", ")", ")", "{", "case", "SET", ":", "set_dest", "=", "SET_DEST", "(", "set_body", ")", ";", "if", "(", "!", "set_dest", "||", "!", "REG_P", "(", "set_dest", ")", ")", "return", "false", ";", "break", ";", "case", "PARALLEL", ":", "for", "(", "i", "=", "XVECLEN", "(", "set_body", ",", "0", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "if", "(", "ix86_dep_by_shift_count_body", "(", "XVECEXP", "(", "set_body", ",", "0", ",", "i", ")", ",", "use_body", ")", ")", "return", "true", ";", "default", ":", "return", "false", ";", "break", ";", "}", "switch", "(", "GET_CODE", "(", "use_body", ")", ")", "{", "case", "SET", ":", "shift_rtx", "=", "XEXP", "(", "use_body", ",", "1", ")", ";", "break", ";", "case", "PARALLEL", ":", "for", "(", "i", "=", "XVECLEN", "(", "use_body", ",", "0", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "if", "(", "ix86_dep_by_shift_count_body", "(", "set_body", ",", "XVECEXP", "(", "use_body", ",", "0", ",", "i", ")", ")", ")", "return", "true", ";", "default", ":", "return", "false", ";", "break", ";", "}", "if", "(", "shift_rtx", "&&", "(", "GET_CODE", "(", "shift_rtx", ")", "==", "ASHIFT", "||", "GET_CODE", "(", "shift_rtx", ")", "==", "LSHIFTRT", "||", "GET_CODE", "(", "shift_rtx", ")", "==", "ASHIFTRT", "||", "GET_CODE", "(", "shift_rtx", ")", "==", "ROTATE", "||", "GET_CODE", "(", "shift_rtx", ")", "==", "ROTATERT", ")", ")", "{", "rtx", "shift_count", "=", "XEXP", "(", "shift_rtx", ",", "1", ")", ";", "if", "(", "REG_P", "(", "shift_count", ")", ")", "{", "if", "(", "reload_completed", "&&", "true_regnum", "(", "set_dest", ")", "==", "true_regnum", "(", "shift_count", ")", ")", "return", "true", ";", "else", "if", "(", "REGNO", "(", "set_dest", ")", "==", "REGNO", "(", "shift_count", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "destination", "reg", "of", "SET_BODY", "is", "shift", "count", "of", "USE_BODY", "." ]

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

[]

[ "<s>", "bool", "SIInstrInfo", "::", "shouldClusterMemOps", "(", "ArrayRef", "<", "const", "MachineOperand", "*", ">", "BaseOps1", ",", "ArrayRef", "<", "const", "MachineOperand", "*", ">", "BaseOps2", ",", "unsigned", "NumLoads", ",", "unsigned", "NumBytes", ")", "const", "{", "assert", "(", "!", "BaseOps1", ".", "empty", "(", ")", "&&", "!", "BaseOps2", ".", "empty", "(", ")", ")", ";", "const", "MachineInstr", "&", "FirstLdSt", "=", "*", "BaseOps1", ".", "front", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineInstr", "&", "SecondLdSt", "=", "*", "BaseOps2", ".", "front", "(", ")", "->", "getParent", "(", ")", ";", "if", "(", "!", "memOpsHaveSameBasePtr", "(", "FirstLdSt", ",", "BaseOps1", ",", "SecondLdSt", ",", "BaseOps2", ")", ")", "return", "false", ";", "const", "unsigned", "LoadSize", "=", "NumBytes", "/", "NumLoads", ";", "const", "unsigned", "NumDWORDs", "=", "(", "(", "LoadSize", "+", "3", ")", "/", "4", ")", "*", "NumLoads", ";", "return", "NumDWORDs", "<=", "8", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "two", "given", "memory", "operations", "should", "be", "scheduled", "adjacent", "." ]

[ "AMDGPU", "SI", "3", "4", "8" ]

[]

[ "<s>", "static", "bool", "cris_rtx_costs", "(", "rtx", "x", ",", "int", "code", ",", "int", "outer_code", ",", "int", "opno", ",", "int", "*", "total", ",", "bool", "speed", ")", "{", "switch", "(", "code", ")", "{", "case", "CONST_INT", ":", "{", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "x", ")", ";", "if", "(", "val", "==", "0", ")", "*", "total", "=", "0", ";", "else", "if", "(", "val", "<", "32", "&&", "val", ">=", "-", "32", ")", "*", "total", "=", "1", ";", "else", "if", "(", "val", "<=", "32767", "&&", "val", ">=", "-", "32768", ")", "*", "total", "=", "2", ";", "else", "*", "total", "=", "4", ";", "return", "true", ";", "}", "case", "LABEL_REF", ":", "*", "total", "=", "6", ";", "return", "true", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "*", "total", "=", "6", ";", "return", "true", ";", "case", "CONST_DOUBLE", ":", "if", "(", "x", "!=", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", "==", "VOIDmode", "?", "DImode", ":", "GET_MODE", "(", "x", ")", ")", ")", "*", "total", "=", "12", ";", "else", "*", "total", "=", "0", ";", "return", "true", ";", "case", "MULT", ":", "if", "(", "outer_code", "==", "PLUS", "&&", "cris_biap_index_p", "(", "x", ",", "false", ")", ")", "{", "*", "total", "=", "0", ";", "return", "true", ";", "}", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "||", "exact_log2", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "<", "0", ")", ")", "{", "if", "(", "TARGET_HAS_MUL_INSNS", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", "+", "COSTS_N_INSNS", "(", "1", ")", "/", "2", ";", "return", "true", ";", "}", "*", "total", "=", "COSTS_N_INSNS", "(", "132", ")", ";", "return", "true", ";", "}", "return", "false", ";", "case", "UDIV", ":", "case", "MOD", ":", "case", "UMOD", ":", "case", "DIV", ":", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "||", "exact_log2", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "<", "0", ")", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "260", ")", ";", "return", "true", ";", "}", "return", "false", ";", "case", "AND", ":", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "!", "satisfies_constraint_I", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "*", "total", "=", "(", "rtx_cost", "(", "XEXP", "(", "x", ",", "0", ")", ",", "(", "enum", "rtx_code", ")", "outer_code", ",", "opno", ",", "speed", ")", "+", "2", "+", "2", "*", "GET_MODE_NUNITS", "(", "GET_MODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "case", "ZERO_EXTRACT", ":", "if", "(", "outer_code", "!=", "COMPARE", ")", "return", "false", ";", "case", "ZERO_EXTEND", ":", "case", "SIGN_EXTEND", ":", "*", "total", "=", "rtx_cost", "(", "XEXP", "(", "x", ",", "0", ")", ",", "(", "enum", "rtx_code", ")", "outer_code", ",", "opno", ",", "speed", ")", ";", "return", "true", ";", "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", "." ]

[ "cris", "0", "0", "32", "32", "1", "32767", "32768", "2", "4", "6", "6", "12", "0", "0", "1", "1", "0", "1", "1", "2", "132", "1", "1", "0", "260", "1", "0", "1", "0", "2", "2", "0", "0" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "MOSFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "int64_t", "Offset", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "hasReservedCallFrame", "(", "MF", ")", "||", "!", "Offset", ")", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "MachineIRBuilder", "Builder", "(", "MBB", ",", "MI", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", "->", "getCallFrameSetupOpcode", "(", ")", ")", "Offset", "=", "-", "Offset", ";", "offsetSP", "(", "Builder", ",", "Offset", ")", ";", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "</s>" ]

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

[ "MOS", "MOS", "0" ]

[]

[ "<s>", "EVT", "PPCTargetLowering", "::", "getSetCCResultType", "(", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "Subtarget", ".", "useCRBits", "(", ")", "?", "MVT", "::", "i1", ":", "MVT", "::", "i32", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "MVT::i1", "MVT::i32" ]

[]

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

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

[ "PowerPC", "MVT::i32" ]

[]

[ "<s>", "static", "void", "unicosmk_output_externs", "(", "FILE", "*", "file", ")", "{", "struct", "unicosmk_extern_list", "*", "p", ";", "const", "char", "*", "real_name", ";", "int", "len", ";", "tree", "name_tree", ";", "len", "=", "strlen", "(", "user_label_prefix", ")", ";", "for", "(", "p", "=", "unicosmk_extern_head", ";", "p", "!=", "0", ";", "p", "=", "p", "->", "next", ")", "{", "real_name", "=", "default_strip_name_encoding", "(", "p", "->", "name", ")", ";", "if", "(", "len", "&&", "p", "->", "name", "[", "0", "]", "==", "'*'", "&&", "!", "memcmp", "(", "real_name", ",", "user_label_prefix", ",", "len", ")", ")", "real_name", "+=", "len", ";", "name_tree", "=", "get_identifier", "(", "real_name", ")", ";", "if", "(", "!", "TREE_ASM_WRITTEN", "(", "name_tree", ")", ")", "{", "TREE_ASM_WRITTEN", "(", "name_tree", ")", "=", "1", ";", "fputs", "(", "\"\\t.extern\\t\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "p", "->", "name", ")", ";", "putc", "(", "'\\n'", ",", "file", ")", ";", "}", "}", "}", "</s>" ]

[ "Output", "extern", "declarations", "for", "global", "symbols", "which", "are", "have", "been", "referenced", "but", "not", "defined", "." ]

[ "alpha", "0", "0", "1", "\"\\t.extern\\t\"" ]

[]