Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "handle_arm_neon_h", "(", "void", ")", "{", "aarch64_simd_switcher", "simd", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "ARM_NEON_H_TYPES_LAST", ";", "i", "++", ")", "for", "(", "unsigned", "int", "count", "=", "2", ";", "count", "<=", "4", ";", "++", "count", ")", "if", "(", "!", "aarch64_scalar_builtin_type_p", "(", "aarch64_simd_types", "[", "i", "]", ".", "type", ")", ")", "register_tuple_type", "(", "count", ",", "i", ")", ";", "aarch64_init_simd_builtin_functions", "(", "true", ")", ";", "}", "</s>" ]

[ "Implement", "#", "pragma", "GCC", "aarch64", "``", "arm_neon.h", "''", ".", "The", "types", "and", "functions", "defined", "here", "need", "to", "be", "available", "internally", "during", "LTO", "as", "well", "." ]

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

[]

[ "<s>", "static", "bool", "rs6000_emit_move_si_sf_subreg", "(", "rtx", "dest", ",", "rtx", "source", ",", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_DIRECT_MOVE_64BIT", "&&", "!", "lra_in_progress", "&&", "!", "reload_completed", "&&", "(", "!", "SUBREG_P", "(", "dest", ")", "||", "!", "sf_subreg_operand", "(", "dest", ",", "mode", ")", ")", "&&", "SUBREG_P", "(", "source", ")", "&&", "sf_subreg_operand", "(", "source", ",", "mode", ")", ")", "{", "rtx", "inner_source", "=", "SUBREG_REG", "(", "source", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE", "(", "inner_source", ")", ";", "if", "(", "mode", "==", "SImode", "&&", "inner_mode", "==", "SFmode", ")", "{", "emit_insn", "(", "gen_movsi_from_sf", "(", "dest", ",", "inner_source", ")", ")", ";", "return", "true", ";", "}", "if", "(", "mode", "==", "SFmode", "&&", "inner_mode", "==", "SImode", ")", "{", "emit_insn", "(", "gen_movsf_from_si", "(", "dest", ",", "inner_source", ")", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Helper", "function", "to", "change", "moves", "with", ":", "(", "SUBREG", ":", "SF", "(", "REG", ":", "SI", ")", ")", "and", "(", "SUBREG", ":", "SI", "(", "REG", ":", "SF", ")", ")", "into", "separate", "UNSPEC", "insns", ".", "In", "the", "PowerPC", "architecture", ",", "scalar", "SFmode", "values", "are", "stored", "as", "DFmode", "values", "in", "the", "VSX", "registers", ".", "We", "need", "to", "convert", "the", "bits", "before", "we", "can", "use", "a", "direct", "move", "or", "operate", "on", "the", "bits", "in", "the", "vector", "register", "as", "an", "integer", "type", ".", "Skip", "things", "like", "(", "set", "(", "SUBREG", ":", "SI", "(", "...", ")", "(", "SUBREG", ":", "SI", "(", "...", ")", ")", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "bool", "v850_pass_by_reference", "(", "cumulative_args_t", ",", "const", "function_arg_info", "&", "arg", ")", "{", "if", "(", "!", "TARGET_GCC_ABI", ")", "return", "0", ";", "unsigned", "HOST_WIDE_INT", "size", "=", "arg", ".", "type_size_in_bytes", "(", ")", ";", "return", "size", ">", "8", ";", "}", "</s>" ]

[ "Handle", "the", "TARGET_PASS_BY_REFERENCE", "target", "hook", ".", "Specify", "whether", "to", "pass", "the", "argument", "by", "reference", "." ]

[ "v850", "0", "8" ]

[]

[ "<s>", "bool", "SystemZFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";", "if", "(", "SystemZ", "::", "FP64BitRegClass", ".", "contains", "(", "Reg", ")", ")", "TII", "->", "loadRegFromStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "CSI", "[", "I", "]", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "FP64BitRegClass", ",", "TRI", ")", ";", "}", "unsigned", "LowGPR", "=", "ZFI", "->", "getLowSavedGPR", "(", ")", ";", "unsigned", "HighGPR", "=", "ZFI", "->", "getHighSavedGPR", "(", ")", ";", "unsigned", "StartOffset", "=", "RegSpillOffsets", "[", "LowGPR", "]", ";", "if", "(", "LowGPR", ")", "{", "assert", "(", "LowGPR", "!=", "HighGPR", "&&", "\"Should be loading %r15 and something else\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "SystemZ", "::", "LMG", ")", ")", ";", "MIB", ".", "addReg", "(", "LowGPR", ",", "RegState", "::", "Define", ")", ";", "MIB", ".", "addReg", "(", "HighGPR", ",", "RegState", "::", "Define", ")", ";", "MIB", ".", "addReg", "(", "HasFP", "?", "SystemZ", "::", "R11D", ":", "SystemZ", "::", "R15D", ")", ";", "MIB", ".", "addImm", "(", "StartOffset", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "!=", "LowGPR", "&&", "Reg", "!=", "HighGPR", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "}", "}", "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", "(", ")", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "0", "SystemZ::FP64BitRegClass", "SystemZ::FP64BitRegClass", "\"Should be loading %r15 and something else\"", "SystemZ::LMG", "SystemZ::R11D", "SystemZ::R15D", "0" ]

[]

[ "<s>", "bool", "MSP430TargetLowering", "::", "isTruncateFree", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "if", "(", "!", "VT1", ".", "isInteger", "(", ")", "||", "!", "VT2", ".", "isInteger", "(", ")", ")", "return", "false", ";", "return", "(", "VT1", ".", "getFixedSizeInBits", "(", ")", ">", "VT2", ".", "getFixedSizeInBits", "(", ")", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "lowerInterleavedLoad", "(", "LoadInst", "*", "LI", ",", "ArrayRef", "<", "ShuffleVectorInst", "*", ">", "Shuffles", ",", "ArrayRef", "<", "unsigned", ">", "Indices", ",", "unsigned", "Factor", ")", "const", "{", "assert", "(", "Factor", ">=", "2", "&&", "Factor", "<=", "getMaxSupportedInterleaveFactor", "(", ")", "&&", "\"Invalid interleave factor\"", ")", ";", "assert", "(", "!", "Shuffles", ".", "empty", "(", ")", "&&", "\"Empty shufflevector input\"", ")", ";", "assert", "(", "Shuffles", ".", "size", "(", ")", "==", "Indices", ".", "size", "(", ")", "&&", "\"Unmatched number of shufflevectors and indices\"", ")", ";", "VectorType", "*", "VecTy", "=", "Shuffles", "[", "0", "]", "->", "getType", "(", ")", ";", "Type", "*", "EltTy", "=", "VecTy", "->", "getVectorElementType", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "LI", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "unsigned", "VecSize", "=", "DL", ".", "getTypeSizeInBits", "(", "VecTy", ")", ";", "bool", "EltIs64Bits", "=", "DL", ".", "getTypeSizeInBits", "(", "EltTy", ")", "==", "64", ";", "if", "(", "!", "Subtarget", "->", "hasNEON", "(", ")", "||", "(", "VecSize", "!=", "64", "&&", "VecSize", "!=", "128", ")", "||", "EltIs64Bits", ")", "return", "false", ";", "if", "(", "EltTy", "->", "isHalfTy", "(", ")", ")", "return", "false", ";", "if", "(", "EltTy", "->", "isPointerTy", "(", ")", ")", "VecTy", "=", "VectorType", "::", "get", "(", "DL", ".", "getIntPtrType", "(", "EltTy", ")", ",", "VecTy", "->", "getVectorNumElements", "(", ")", ")", ";", "static", "const", "Intrinsic", "::", "ID", "LoadInts", "[", "3", "]", "=", "{", "Intrinsic", "::", "arm_neon_vld2", ",", "Intrinsic", "::", "arm_neon_vld3", ",", "Intrinsic", "::", "arm_neon_vld4", "}", ";", "IRBuilder", "<", ">", "Builder", "(", "LI", ")", ";", "SmallVector", "<", "Value", "*", ",", "2", ">", "Ops", ";", "Type", "*", "Int8Ptr", "=", "Builder", ".", "getInt8PtrTy", "(", "LI", "->", "getPointerAddressSpace", "(", ")", ")", ";", "Ops", ".", "push_back", "(", "Builder", ".", "CreateBitCast", "(", "LI", "->", "getPointerOperand", "(", ")", ",", "Int8Ptr", ")", ")", ";", "Ops", ".", "push_back", "(", "Builder", ".", "getInt32", "(", "LI", "->", "getAlignment", "(", ")", ")", ")", ";", "assert", "(", "isTypeLegal", "(", "EVT", "::", "getEVT", "(", "VecTy", ")", ")", "&&", "\"Illegal vldN vector type!\"", ")", ";", "Type", "*", "Tys", "[", "]", "=", "{", "VecTy", ",", "Int8Ptr", "}", ";", "Function", "*", "VldnFunc", "=", "Intrinsic", "::", "getDeclaration", "(", "LI", "->", "getModule", "(", ")", ",", "LoadInts", "[", "Factor", "-", "2", "]", ",", "Tys", ")", ";", "CallInst", "*", "VldN", "=", "Builder", ".", "CreateCall", "(", "VldnFunc", ",", "Ops", ",", "\"vldN\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Shuffles", ".", "size", "(", ")", ";", "i", "++", ")", "{", "ShuffleVectorInst", "*", "SV", "=", "Shuffles", "[", "i", "]", ";", "unsigned", "Index", "=", "Indices", "[", "i", "]", ";", "Value", "*", "SubVec", "=", "Builder", ".", "CreateExtractValue", "(", "VldN", ",", "Index", ")", ";", "if", "(", "EltTy", "->", "isPointerTy", "(", ")", ")", "SubVec", "=", "Builder", ".", "CreateIntToPtr", "(", "SubVec", ",", "SV", "->", "getType", "(", ")", ")", ";", "SV", "->", "replaceAllUsesWith", "(", "SubVec", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Lower", "interleaved", "load", "(", "s", ")", "into", "target", "specific", "instructions/intrinsics", "." ]

[ "ARM", "ARM", "2", "\"Invalid interleave factor\"", "\"Empty shufflevector input\"", "\"Unmatched number of shufflevectors and indices\"", "0", "64", "64", "128", "Intrinsic::ID", "3", "Intrinsic::arm_neon_vld2", "Intrinsic::arm_neon_vld3", "Intrinsic::arm_neon_vld4", "2", "\"Illegal vldN vector type!\"", "Intrinsic::getDeclaration", "2", "\"vldN\"", "0" ]

[]

[ "<s>", "void", "cr16_decompose_const", "(", "rtx", "x", ",", "int", "*", "code", ",", "enum", "data_model_type", "*", "data", ",", "bool", "treat_as_const", ")", "{", "*", "code", "=", "-", "1", ";", "*", "data", "=", "ILLEGAL_DM", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "SYMBOL_REF", ":", "*", "code", "=", "SYMBOL_REF_FUNCTION_P", "(", "x", ")", "?", "2", ":", "0", ";", "if", "(", "*", "code", "==", "0", ")", "{", "if", "(", "CR16_TARGET_DATA_NEAR", ")", "*", "data", "=", "DM_DEFAULT", ";", "else", "if", "(", "CR16_TARGET_DATA_MEDIUM", ")", "*", "data", "=", "DM_FAR", ";", "else", "if", "(", "CR16_TARGET_DATA_FAR", ")", "{", "if", "(", "treat_as_const", ")", "*", "data", "=", "DM_FAR", ";", "else", "*", "data", "=", "ILLEGAL_DM", ";", "}", "}", "return", ";", "case", "LABEL_REF", ":", "*", "code", "=", "1", ";", "return", ";", "case", "PLUS", ":", "case", "MINUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "CONST_INT", ")", "cr16_decompose_const", "(", "XEXP", "(", "x", ",", "1", ")", ",", "code", ",", "data", ",", "treat_as_const", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "cr16_decompose_const", "(", "XEXP", "(", "x", ",", "0", ")", ",", "code", ",", "data", ",", "treat_as_const", ")", ";", "return", ";", "default", ":", "return", ";", "}", "}", "</s>" ]

[ "Helper", "functions", ":", "Created", "specifically", "for", "decomposing", "operand", "of", "CONST", "Recursively", "look", "into", "expression", "x", "for", "code", "or", "data", "symbol", ".", "The", "function", "expects", "the", "expression", "to", "contain", "combination", "of", "SYMBOL_REF", ",", "CONST_INT", ",", "(", "PLUS", "or", "MINUS", ")", "LABEL_REF", ",", "CONST_INT", ",", "(", "PLUS", "or", "MINUS", ")", "SYMBOL_REF", "LABEL_REF", "All", "other", "combinations", "will", "result", "in", "code", "=", "-1", "and", "data", "=", "ILLEGAL_DM", "code", "data", "-1", "ILLEGAL_DM", "The", "expression", "did", "not", "contain", "SYMBOL_REF", "or", "LABEL_REF", "0", "DM_FAR", "SYMBOL_REF", "was", "found", "and", "it", "was", "far", "data", "reference", ".", "0", "DM_DEFAULT", "SYMBOL_REF", "was", "found", "and", "it", "was", "medium", "data", "reference", ".", "1", "ILLEGAL_DM", "LABEL_REF", "was", "found", ".", "2", "ILLEGAL_DM", "SYMBOL_REF", "was", "found", "and", "it", "was", "function", "reference", "." ]

[ "cr16", "1", "2", "0", "0", "1", "0", "1", "1", "0" ]

[]

[ "<s>", "size_t", "AMDGPUPeepholeOpt", "::", "getTypeSize", "(", "OpaqueType", "*", "const", "OT", ",", "bool", "dereferencePtr", ")", "{", "return", "4", ";", "}", "</s>" ]

[ "Gets", "the", "type", "size", "(", "in", "bytes", ")", "for", "this", "DIE", "." ]

[ "R600", "4" ]

[]

[ "<s>", "MachineBasicBlock", "*", "CSKYTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "CSKY", "::", "FSELS", ":", "case", "CSKY", "::", "FSELD", ":", "if", "(", "Subtarget", ".", "hasE2", "(", ")", ")", "return", "emitSelectPseudo", "(", "MI", ",", "BB", ",", "CSKY", "::", "BT32", ")", ";", "else", "return", "emitSelectPseudo", "(", "MI", ",", "BB", ",", "CSKY", "::", "BT16", ")", ";", "case", "CSKY", "::", "ISEL32", ":", "return", "emitSelectPseudo", "(", "MI", ",", "BB", ",", "CSKY", "::", "BT32", ")", ";", "case", "CSKY", "::", "ISEL16", ":", "return", "emitSelectPseudo", "(", "MI", ",", "BB", ",", "CSKY", "::", "BT16", ")", ";", "}", "}", "</s>" ]

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

[ "CSKY", "CSKY", "\"Unexpected instr type to insert\"", "CSKY::FSELS", "CSKY::FSELD", "CSKY::BT32", "CSKY::BT16", "CSKY::ISEL32", "CSKY::BT32", "CSKY::ISEL16", "CSKY::BT16" ]

[]

[ "<s>", "bool", "XCoreTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "EVT", ">", "&", "OutTys", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "ArgFlagsTy", ">", "&", "ArgsFlags", ",", "SelectionDAG", "&", "DAG", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "OutTys", ",", "ArgsFlags", ",", "RetCC_XCore", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "ISD::ArgFlagsTy", "16", "XCore" ]

[]

[ "<s>", "static", "void", "s390_add_constant", "(", "struct", "constant_pool", "*", "pool", ",", "rtx", "val", ",", "enum", "machine_mode", "mode", ")", "{", "struct", "constant", "*", "c", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NR_C_MODES", ";", "i", "++", ")", "if", "(", "constant_modes", "[", "i", "]", "==", "mode", ")", "break", ";", "gcc_assert", "(", "i", "!=", "NR_C_MODES", ")", ";", "for", "(", "c", "=", "pool", "->", "constants", "[", "i", "]", ";", "c", "!=", "NULL", ";", "c", "=", "c", "->", "next", ")", "if", "(", "rtx_equal_p", "(", "val", ",", "c", "->", "value", ")", ")", "break", ";", "if", "(", "c", "==", "NULL", ")", "{", "c", "=", "(", "struct", "constant", "*", ")", "xmalloc", "(", "sizeof", "*", "c", ")", ";", "c", "->", "value", "=", "val", ";", "c", "->", "label", "=", "gen_label_rtx", "(", ")", ";", "c", "->", "next", "=", "pool", "->", "constants", "[", "i", "]", ";", "pool", "->", "constants", "[", "i", "]", "=", "c", ";", "pool", "->", "size", "+=", "GET_MODE_SIZE", "(", "mode", ")", ";", "}", "}", "</s>" ]

[ "Add", "constant", "VAL", "of", "mode", "MODE", "to", "the", "constant", "pool", "POOL", "." ]

[ "s390", "0" ]

[]

[ "<s>", "bool", "avr_popcount_each_byte", "(", "rtx", "xval", ",", "int", "n_bytes", ",", "int", "pop_mask", ")", "{", "int", "i", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "xval", ")", ";", "if", "(", "VOIDmode", "==", "mode", ")", "mode", "=", "SImode", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_bytes", ";", "i", "++", ")", "{", "rtx", "xval8", "=", "simplify_gen_subreg", "(", "QImode", ",", "xval", ",", "mode", ",", "i", ")", ";", "unsigned", "int", "val8", "=", "UINTVAL", "(", "xval8", ")", "&", "GET_MODE_MASK", "(", "QImode", ")", ";", "if", "(", "0", "==", "(", "pop_mask", "&", "(", "1", "<<", "avr_popcount", "(", "val8", ")", ")", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Constraint", "helper", "function", ".", "XVAL", "is", "a", "CONST_INT", "or", "a", "CONST_DOUBLE", ".", "Return", "true", "if", "the", "least", "significant", "N_BYTES", "bytes", "of", "XVAL", "all", "have", "a", "popcount", "in", "POP_MASK", "and", "false", ",", "otherwise", ".", "POP_MASK", "represents", "a", "subset", "of", "integers", "which", "contains", "an", "integer", "N", "iff", "bit", "N", "of", "POP_MASK", "is", "set", "." ]

[ "avr", "0", "0", "1" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "AArch64TargetLowering", "::", "shouldExpandAtomicLoadInIR", "(", "LoadInst", "*", "LI", ")", "const", "{", "unsigned", "Size", "=", "LI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "Size", "!=", "128", "||", "isOpSuitableForLDPSTP", "(", "LI", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "return", "AtomicExpansionKind", "::", "LLSC", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "(", "atomic", ")", "load", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "." ]

[ "AArch64", "AArch64", "128" ]

[]

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

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

[ "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86::VR128RegClass" ]

[]

[ "<s>", "unsigned", "PPCInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "STD", ":", "case", "PPC", "::", "STW", ":", "case", "PPC", "::", "STFS", ":", "case", "PPC", "::", "STFD", ":", "case", "PPC", "::", "SPILL_CR", ":", "case", "PPC", "::", "SPILL_CRBIT", ":", "case", "PPC", "::", "STVX", ":", "case", "PPC", "::", "STXVD2X", ":", "case", "PPC", "::", "SPILL_VRSAVE", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "!", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::STD", "PPC::STW", "PPC::STFS", "PPC::STFD", "PPC::SPILL_CR", "PPC::SPILL_CRBIT", "PPC::STVX", "PPC::STXVD2X", "PPC::SPILL_VRSAVE", "1", "1", "2", "2", "0", "0" ]

[]

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

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

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

[]

[ "<s>", "bool", "R600InstrInfo", "::", "isPredicated", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "int", "idx", "=", "MI", ".", "findFirstPredOperandIdx", "(", ")", ";", "if", "(", "idx", "<", "0", ")", "return", "false", ";", "unsigned", "Reg", "=", "MI", ".", "getOperand", "(", "idx", ")", ".", "getReg", "(", ")", ";", "switch", "(", "Reg", ")", "{", "default", ":", "return", "false", ";", "case", "R600", "::", "PRED_SEL_ONE", ":", "case", "R600", "::", "PRED_SEL_ZERO", ":", "case", "R600", "::", "PREDICATE_BIT", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "already", "predicated", "." ]

[ "AMDGPU", "R600", "0", "R600::PRED_SEL_ONE", "R600::PRED_SEL_ZERO", "R600::PREDICATE_BIT" ]

[]

[ "<s>", "BitVector", "PPCRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "PPCFrameLowering", "*", "PPCFI", "=", "static_cast", "<", "const", "PPCFrameLowering", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "ZERO", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "ZERO8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "FP", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "FP8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "BP", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "BP8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "CTR", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "CTR8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R1", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "LR", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "LR8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "RM", ")", ";", "if", "(", "!", "Subtarget", ".", "isDarwinABI", "(", ")", "||", "!", "Subtarget", ".", "hasAltivec", "(", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "VRSAVE", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "R2", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R13", ")", ";", "}", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "R13", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X1", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X13", ")", ";", "if", "(", "PPCFI", "->", "needsFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "X31", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "X30", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "X2", ")", ";", "}", "}", "if", "(", "PPCFI", "->", "needsFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "R31", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "R30", ")", ";", "if", "(", "!", "Subtarget", ".", "hasAltivec", "(", ")", ")", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "PPC", "::", "VRRCRegClass", ".", "begin", "(", ")", ",", "IE", "=", "PPC", "::", "VRRCRegClass", ".", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC::ZERO", "PPC::ZERO8", "PPC::FP", "PPC::FP8", "PPC::BP", "PPC::BP8", "PPC::CTR", "PPC::CTR8", "PPC::R1", "PPC::LR", "PPC::LR8", "PPC::RM", "PPC::VRSAVE", "PPC::R2", "PPC::R13", "PPC", "PPC::R13", "PPC::X1", "PPC::X13", "PPC", "PPC::X31", "PPC::X30", "PPC::X2", "PPC", "PPC::R31", "PPC::R30", "PPC::VRRCRegClass", "PPC::VRRCRegClass" ]

[]

[ "<s>", "static", "MUL_TYPE", "add", "(", "MUL_TYPE", "n1", ",", "MUL_TYPE", "n2", ")", "{", "return", "n1", "+", "n2", ";", "}", "</s>" ]

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

[ "tilepro" ]

[]

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

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

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

[]

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

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

[ "RI5CY", "0", "0" ]

[]

[ "<s>", "static", "void", "s390_asm_file_end", "(", "void", ")", "{", "varpool_node", "*", "vnode", ";", "cgraph_node", "*", "cnode", ";", "FOR_EACH_VARIABLE", "(", "vnode", ")", "if", "(", "TREE_PUBLIC", "(", "vnode", "->", "decl", ")", ")", "s390_check_type_for_vector_abi", "(", "TREE_TYPE", "(", "vnode", "->", "decl", ")", ",", "false", ",", "false", ")", ";", "FOR_EACH_FUNCTION", "(", "cnode", ")", "if", "(", "TREE_PUBLIC", "(", "cnode", "->", "decl", ")", ")", "s390_check_type_for_vector_abi", "(", "TREE_TYPE", "(", "cnode", "->", "decl", ")", ",", "false", ",", "false", ")", ";", "if", "(", "s390_vector_abi", "!=", "0", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.gnu_attribute 8, %d\\n\"", ",", "s390_vector_abi", ")", ";", "file_end_indicate_exec_stack", "(", ")", ";", "if", "(", "flag_split_stack", ")", "file_end_indicate_split_stack", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_FILE_END", "." ]

[ "s390", "0", "\"\\t.gnu_attribute 8, %d\\n\"" ]

[]

[ "<s>", "SMLoc", "getStartLoc", "(", ")", "const", "{", "return", "StartLoc", ";", "}", "</s>" ]

[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]

[ "Mips" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isVectorClearMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "Mask", ",", "EVT", "VT", ")", "const", "{", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "NumElts", "==", "2", ")", "return", "true", ";", "if", "(", "NumElts", "==", "4", "&&", "VT", ".", "is128BitVector", "(", ")", ")", "{", "return", "(", "isMOVLMask", "(", "Mask", ",", "VT", ")", "||", "isCommutedMOVLMask", "(", "Mask", ",", "VT", ",", "true", ")", "||", "isSHUFPMask", "(", "Mask", ",", "VT", ",", "Subtarget", "->", "hasFp256", "(", ")", ")", "||", "isSHUFPMask", "(", "Mask", ",", "VT", ",", "Subtarget", "->", "hasFp256", "(", ")", ",", "true", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Similar", "to", "isShuffleMaskLegal", "." ]

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

[]

[ "<s>", "int", "SystemZTTIImpl", "::", "getIntrinsicInstrCost", "(", "Intrinsic", "::", "ID", "ID", ",", "Type", "*", "RetTy", ",", "ArrayRef", "<", "Type", "*", ">", "Tys", ",", "FastMathFlags", "FMF", ",", "unsigned", "ScalarizationCostPassed", ")", "{", "int", "Cost", "=", "getVectorIntrinsicInstrCost", "(", "ID", ",", "RetTy", ")", ";", "if", "(", "Cost", "!=", "-", "1", ")", "return", "Cost", ";", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ID", ",", "RetTy", ",", "Tys", ",", "FMF", ",", "ScalarizationCostPassed", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "Intrinsic::ID", "1" ]

[]

[ "<s>", "static", "void", "init_insn_group_barriers", "(", "void", ")", "{", "memset", "(", "rws_sum", ",", "0", ",", "sizeof", "(", "rws_sum", ")", ")", ";", "first_instruction", "=", "1", ";", "}", "</s>" ]

[ "Clear", "out", "the", "state", "for", "group_barrier_needed_p", "at", "the", "start", "of", "a", "sequence", "of", "insns", "." ]

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

[]

[ "<s>", "static", "void", "c6x_set_sched_context", "(", "void", "*", "_sc", ")", "{", "c6x_sched_context_t", "sc", "=", "(", "c6x_sched_context_t", ")", "_sc", ";", "gcc_assert", "(", "sc", "!=", "NULL", ")", ";", "ss", "=", "*", "sc", ";", "memcpy", "(", "prev_cycle_state", ",", "sc", "->", "prev_cycle_state_ctx", ",", "dfa_state_size", ")", ";", "}", "</s>" ]

[ "Sets", "the", "global", "scheduling", "context", "to", "the", "one", "pointed", "to", "by", "_SC", "." ]

[ "c6x" ]

[]

[ "<s>", "static", "inline", "_uw", "selfrel_offset31", "(", "const", "_uw", "*", "p", ")", "{", "_uw", "offset", ";", "offset", "=", "*", "p", ";", "if", "(", "offset", "&", "(", "1", "<<", "30", ")", ")", "offset", "|=", "1u", "<<", "31", ";", "return", "offset", "+", "(", "_uw", ")", "p", ";", "}", "</s>" ]

[ "Calculate", "the", "address", "encoded", "by", "a", "31-bit", "self-relative", "offset", "at", "address", "P", "." ]

[ "arm", "1", "30", "1u", "31" ]

[]

[ "<s>", "static", "void", "mips_set_architecture", "(", "const", "struct", "mips_cpu_info", "*", "info", ")", "{", "if", "(", "info", "!=", "0", ")", "{", "mips_arch_info", "=", "info", ";", "mips_arch", "=", "info", "->", "cpu", ";", "mips_isa", "=", "info", "->", "isa", ";", "if", "(", "mips_isa", "<", "MIPS_ISA_MIPS32", ")", "mips_isa_rev", "=", "0", ";", "else", "mips_isa_rev", "=", "(", "mips_isa", "&", "31", ")", "+", "1", ";", "}", "}", "</s>" ]

[ "Set", "up", "globals", "to", "generate", "code", "for", "the", "ISA", "or", "processor", "described", "by", "INFO", "." ]

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

[]

[ "<s>", "poly_uint64", "aarch64_regmode_natural_size", "(", "machine_mode", "mode", ")", "{", "if", "(", "!", "aarch64_sve_vg", ".", "is_constant", "(", ")", ")", "{", "unsigned", "int", "vec_flags", "=", "aarch64_classify_vector_mode", "(", "mode", ")", ";", "if", "(", "vec_flags", "&", "VEC_SVE_PRED", ")", "return", "BYTES_PER_SVE_PRED", ";", "if", "(", "vec_flags", "&", "VEC_SVE_DATA", ")", "return", "BYTES_PER_SVE_VECTOR", ";", "}", "return", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Implement", "REGMODE_NATURAL_SIZE", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "MCS51AsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "adjustFixupValue", "(", "Fixup", ",", "Target", ",", "Value", ",", "&", "Asm", ".", "getContext", "(", ")", ")", ";", "if", "(", "Value", "==", "0", ")", "return", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "auto", "NumBits", "=", "Info", ".", "TargetSize", "+", "Info", ".", "TargetOffset", ";", "auto", "NumBytes", "=", "(", "NumBits", "/", "8", ")", "+", "(", "(", "NumBits", "%", "8", ")", "==", "0", "?", "0", ":", "1", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumBytes", ";", "++", "i", ")", "{", "uint8_t", "mask", "=", "(", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ")", ";", "Data", "[", "Offset", "+", "i", "]", "|=", "mask", ";", "}", "}", "</s>" ]

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

[ "MCS51", "MCS51", "0", "8", "8", "0", "0", "1", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "static", "void", "emit_cfa_restores", "(", "rtx", "cfa_restores", ")", "{", "rtx_insn", "*", "insn", "=", "get_last_insn", "(", ")", ";", "rtx", "*", "loc", "=", "&", "REG_NOTES", "(", "insn", ")", ";", "while", "(", "*", "loc", ")", "loc", "=", "&", "XEXP", "(", "*", "loc", ",", "1", ")", ";", "*", "loc", "=", "cfa_restores", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Append", "CFA_RESTORES", "to", "any", "existing", "REG_NOTES", "on", "the", "last", "insn", "." ]

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

[]

[ "<s>", "const", "uint32_t", "*", "X86RegisterInfo", "::", "getNoPreservedMask", "(", ")", "const", "{", "return", "CSR_NoRegs_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "register", "mask", "that", "clobbers", "everything", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "XtensaFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "assert", "(", "false", "&&", "\"XtensaFrameLowering::hasFP not implemented\"", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "\"XtensaFrameLowering::hasFP not implemented\"" ]

[]

[ "<s>", "bool", "AMDGPUCodeGenPrepare", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "TM", "||", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "ST", "=", "&", "TM", "->", "getSubtarget", "<", "SISubtarget", ">", "(", "F", ")", ";", "DA", "=", "&", "getAnalysis", "<", "DivergenceAnalysis", ">", "(", ")", ";", "HasUnsafeFPMath", "=", "hasUnsafeFPMath", "(", "F", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "BasicBlock", "::", "iterator", "Next", ";", "for", "(", "BasicBlock", "::", "iterator", "I", "=", "BB", ".", "begin", "(", ")", ",", "E", "=", "BB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MadeChange", "|=", "visit", "(", "*", "I", ")", ";", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "ARMAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "*", "AsmOp", ",", "unsigned", "Kind", ")", "{", "ARMOperand", "*", "Op", "=", "static_cast", "<", "ARMOperand", "*", ">", "(", "AsmOp", ")", ";", "if", "(", "Kind", "==", "MCK__35_0", "&&", "Op", "->", "isImm", "(", ")", ")", "{", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", "->", "getImm", "(", ")", ")", ";", "if", "(", "!", "CE", ")", "return", "Match_InvalidOperand", ";", "if", "(", "CE", "->", "getValue", "(", ")", "==", "0", ")", "return", "Match_Success", ";", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

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

[]

[ "<s>", "unsigned", "AMDGPUAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "Op", ",", "unsigned", "Kind", ")", "{", "AMDGPUOperand", "&", "Operand", "=", "(", "AMDGPUOperand", "&", ")", "Op", ";", "switch", "(", "Kind", ")", "{", "case", "MCK_addr64", ":", "return", "Operand", ".", "isAddr64", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_gds", ":", "return", "Operand", ".", "isGDS", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_glc", ":", "return", "Operand", ".", "isGLC", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_idxen", ":", "return", "Operand", ".", "isIdxen", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_offen", ":", "return", "Operand", ".", "isOffen", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_SSrcB32", ":", "return", "Operand", ".", "isSSrcB32", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_SSrcF32", ":", "return", "Operand", ".", "isSSrcF32", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_SoppBrTarget", ":", "return", "Operand", ".", "isSoppBrTarget", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_VReg32OrOff", ":", "return", "Operand", ".", "isVReg32OrOff", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_InterpSlot", ":", "return", "Operand", ".", "isInterpSlot", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_Attr", ":", "return", "Operand", ".", "isInterpAttr", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_AttrChan", ":", "return", "Operand", ".", "isAttrChan", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "default", ":", "return", "Match_InvalidOperand", ";", "}", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

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

[]

[ "<s>", "struct", "machine_function", "*", "rs6000_init_machine_status", "(", "void", ")", "{", "stack_info", ".", "reload_completed", "=", "0", ";", "return", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "}", "</s>" ]

[ "Functions", "to", "init", ",", "mark", "and", "free", "struct", "machine_function", ".", "These", "will", "be", "called", ",", "via", "pointer", "variables", ",", "from", "push_function_context", "and", "pop_function_context", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "void", "ix86_emit_i387_acosh", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "e1", "=", "gen_reg_rtx", "(", "XFmode", ")", ";", "rtx", "e2", "=", "gen_reg_rtx", "(", "XFmode", ")", ";", "rtx", "cst1", "=", "force_reg", "(", "XFmode", ",", "CONST1_RTX", "(", "XFmode", ")", ")", ";", "emit_insn", "(", "gen_addxf3", "(", "e2", ",", "op1", ",", "cst1", ")", ")", ";", "emit_insn", "(", "gen_sqrtxf2", "(", "e2", ",", "e2", ")", ")", ";", "emit_insn", "(", "gen_subxf3", "(", "e1", ",", "op1", ",", "cst1", ")", ")", ";", "emit_insn", "(", "gen_sqrtxf2", "(", "e1", ",", "e1", ")", ")", ";", "emit_insn", "(", "gen_mulxf3", "(", "e1", ",", "e1", ",", "e2", ")", ")", ";", "emit_insn", "(", "gen_addxf3", "(", "e1", ",", "e1", ",", "op1", ")", ")", ";", "emit_insn", "(", "gen_logxf2", "(", "op0", ",", "e1", ")", ")", ";", "}", "</s>" ]

[ "Output", "code", "to", "perform", "an", "acosh", "XFmode", "calculation", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "cris_return_address_on_stack_for_return", "(", "void", ")", "{", "return", "cfun", "->", "machine", "->", "return_type", "==", "CRIS_RETINSN_RET", "?", "false", ":", "cris_return_address_on_stack", "(", ")", ";", "}", "</s>" ]

[ "Accessor", "used", "in", "cris.md", ":", "return", "because", "cfun-", ">", "machine", "is", "n't", "available", "there", "." ]

[ "cris" ]

[]

[ "<s>", "void", "AMDGPUInstructionSelector", "::", "setupMF", "(", "MachineFunction", "&", "MF", ",", "GISelKnownBits", "*", "KB", ",", "CodeGenCoverage", "&", "CoverageInfo", ",", "ProfileSummaryInfo", "*", "PSI", ",", "BlockFrequencyInfo", "*", "BFI", ",", "AAResults", "*", "AA", ")", "{", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "InstructionSelector", "::", "setupMF", "(", "MF", ",", "KB", ",", "CoverageInfo", ",", "PSI", ",", "BFI", ",", "AA", ")", ";", "}", "</s>" ]

[ "Setup", "per-MF", "executor", "state", "." ]

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

[]

[ "<s>", "static", "int", "num_insns_constant_gpr", "(", "HOST_WIDE_INT", "value", ")", "{", "if", "(", "SIGNED_INTEGER_16BIT_P", "(", "value", ")", ")", "return", "1", ";", "else", "if", "(", "(", "value", "&", "0xffff", ")", "==", "0", "&&", "(", "value", ">>", "31", "==", "-", "1", "||", "value", ">>", "31", "==", "0", ")", ")", "return", "1", ";", "else", "if", "(", "TARGET_PREFIXED", "&&", "SIGNED_INTEGER_34BIT_P", "(", "value", ")", ")", "return", "1", ";", "else", "if", "(", "TARGET_POWERPC64", ")", "{", "HOST_WIDE_INT", "low", "=", "(", "(", "value", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "HOST_WIDE_INT", "high", "=", "value", ">>", "31", ";", "if", "(", "high", "==", "0", "||", "high", "==", "-", "1", ")", "return", "2", ";", "high", ">>=", "1", ";", "if", "(", "low", "==", "0", "||", "low", "==", "high", ")", "return", "num_insns_constant_gpr", "(", "high", ")", "+", "1", ";", "else", "if", "(", "high", "==", "0", ")", "return", "num_insns_constant_gpr", "(", "low", ")", "+", "1", ";", "else", "return", "(", "num_insns_constant_gpr", "(", "high", ")", "+", "num_insns_constant_gpr", "(", "low", ")", "+", "1", ")", ";", "}", "else", "return", "2", ";", "}", "</s>" ]

[ "Helper", "for", "num_insns_constant", ".", "Calculate", "number", "of", "instructions", "to", "load", "VALUE", "to", "a", "single", "gpr", "using", "combinations", "of", "addi", ",", "addis", ",", "ori", ",", "oris", ",", "sldi", "and", "rldimi", "instructions", "." ]

[ "rs6000", "1", "0xffff", "0", "31", "1", "31", "0", "1", "1", "0xffffffff", "0x80000000", "0x80000000", "31", "0", "1", "2", "1", "0", "1", "0", "1", "1", "2" ]

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "XCoreFunctionInfo", "*", "XFI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFrameInfo", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "if", "(", "!", "isVarArg", ")", "CCInfo", ".", "AllocateStack", "(", "XFI", "->", "getReturnStackOffset", "(", ")", ",", "4", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_XCore", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "0", ",", "MVT", "::", "i32", ")", ")", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "MemOpChains", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "continue", ";", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "if", "(", "isVarArg", ")", "{", "report_fatal_error", "(", "\"Can't return value from vararg function in memory\"", ")", ";", "}", "int", "Offset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "ObjSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "8", ";", "int", "FI", "=", "MFI", "->", "CreateFixedObject", "(", "ObjSize", ",", "Offset", ",", "false", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "MemOpChains", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "OutVals", "[", "i", "]", ",", "FIN", ",", "MachinePointerInfo", "::", "getFixedStack", "(", "FI", ")", ",", "false", ",", "false", ",", "0", ")", ")", ";", "}", "if", "(", "!", "MemOpChains", ".", "empty", "(", ")", ")", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "MemOpChains", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "!", "VA", ".", "isRegLoc", "(", ")", ")", "continue", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "XCoreISD", "::", "RETSP", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "ISD::OutputArg", "XCore", "XCore", "16", "4", "XCore", "4", "1", "0", "MVT::i32", "4", "0", "\"Can't return value from vararg function in memory\"", "8", "MVT::i32", "0", "ISD::TokenFactor", "MVT::Other", "0", "1", "0", "XCoreISD::RETSP", "MVT::Other" ]

[]

[ "<s>", "void", "alpha_expand_movmisalign", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "if", "(", "MEM_P", "(", "operands", "[", "1", "]", ")", ")", "{", "rtx", "tmp", ";", "if", "(", "register_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", ")", "tmp", "=", "operands", "[", "0", "]", ";", "else", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "alpha_expand_unaligned_load", "(", "tmp", ",", "operands", "[", "1", "]", ",", "8", ",", "0", ",", "0", ")", ";", "if", "(", "tmp", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "tmp", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", ")", "{", "if", "(", "!", "reg_or_0_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "alpha_expand_unaligned_store", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "8", ",", "0", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "the", "movmisalign", "patterns", ".", "One", "of", "the", "operands", "is", "a", "memory", "that", "is", "not", "naturally", "aligned", ".", "Emit", "instructions", "to", "load", "it", "." ]

[ "alpha", "1", "0", "0", "1", "8", "0", "0", "0", "0", "0", "1", "1", "1", "0", "1", "8", "0" ]

[]

[ "<s>", "unsigned", "AArch64TargetLowering", "::", "getNumInterleavedAccesses", "(", "VectorType", "*", "VecTy", ",", "const", "DataLayout", "&", "DL", ",", "bool", "UseScalable", ")", "const", "{", "unsigned", "VecSize", "=", "UseScalable", "?", "Subtarget", "->", "getMinSVEVectorSizeInBits", "(", ")", ":", "128", ";", "return", "std", "::", "max", "<", "unsigned", ">", "(", "1", ",", "(", "DL", ".", "getTypeSizeInBits", "(", "VecTy", ")", "+", "127", ")", "/", "VecSize", ")", ";", "}", "</s>" ]

[ "Returns", "the", "number", "of", "interleaved", "accesses", "that", "will", "be", "generated", "when", "lowering", "accesses", "of", "the", "given", "type", "." ]

[ "AArch64", "AArch64", "128", "1", "127" ]

[]

[ "<s>", "void", "BTFDebug", "::", "beginFunctionImpl", "(", "const", "MachineFunction", "*", "MF", ")", "{", "auto", "*", "SP", "=", "MF", "->", "getFunction", "(", ")", ".", "getSubprogram", "(", ")", ";", "auto", "*", "Unit", "=", "SP", "->", "getUnit", "(", ")", ";", "if", "(", "Unit", "->", "getEmissionKind", "(", ")", "==", "DICompileUnit", "::", "NoDebug", ")", "{", "SkipInstruction", "=", "true", ";", "return", ";", "}", "SkipInstruction", "=", "false", ";", "std", "::", "unordered_map", "<", "uint32_t", ",", "StringRef", ">", "FuncArgNames", ";", "for", "(", "const", "DINode", "*", "DN", ":", "SP", "->", "getRetainedNodes", "(", ")", ")", "{", "if", "(", "const", "auto", "*", "DV", "=", "dyn_cast", "<", "DILocalVariable", ">", "(", "DN", ")", ")", "{", "uint32_t", "Arg", "=", "DV", "->", "getArg", "(", ")", ";", "if", "(", "Arg", ")", "{", "visitTypeEntry", "(", "DV", "->", "getType", "(", ")", ")", ";", "FuncArgNames", "[", "Arg", "]", "=", "DV", "->", "getName", "(", ")", ";", "}", "}", "}", "uint32_t", "ProtoTypeId", ";", "visitSubroutineType", "(", "SP", "->", "getType", "(", ")", ",", "true", ",", "FuncArgNames", ",", "ProtoTypeId", ")", ";", "auto", "FuncTypeEntry", "=", "llvm", "::", "make_unique", "<", "BTFTypeFunc", ">", "(", "SP", "->", "getName", "(", ")", ",", "ProtoTypeId", ")", ";", "uint32_t", "FuncTypeId", "=", "addType", "(", "std", "::", "move", "(", "FuncTypeEntry", ")", ")", ";", "MCSymbol", "*", "FuncLabel", "=", "Asm", "->", "getFunctionBegin", "(", ")", ";", "BTFFuncInfo", "FuncInfo", ";", "FuncInfo", ".", "Label", "=", "FuncLabel", ";", "FuncInfo", ".", "TypeId", "=", "FuncTypeId", ";", "if", "(", "FuncLabel", "->", "isInSection", "(", ")", ")", "{", "MCSection", "&", "Section", "=", "FuncLabel", "->", "getSection", "(", ")", ";", "const", "MCSectionELF", "*", "SectionELF", "=", "dyn_cast", "<", "MCSectionELF", ">", "(", "&", "Section", ")", ";", "assert", "(", "SectionELF", "&&", "\"Null section for Function Label\"", ")", ";", "SecNameOff", "=", "addString", "(", "SectionELF", "->", "getSectionName", "(", ")", ")", ";", "}", "else", "{", "SecNameOff", "=", "addString", "(", "\".text\"", ")", ";", "}", "FuncInfoTable", "[", "SecNameOff", "]", ".", "push_back", "(", "FuncInfo", ")", ";", "}", "</s>" ]

[ "Gather", "pre-function", "debug", "information", "." ]

[ "BPF", "\"Null section for Function Label\"", "\".text\"" ]

[]

[ "<s>", "static", "bool", "arc_warn_func_return", "(", "tree", "decl", ")", "{", "struct", "function", "*", "func", "=", "DECL_STRUCT_FUNCTION", "(", "decl", ")", ";", "unsigned", "int", "fn_type", "=", "arc_compute_function_type", "(", "func", ")", ";", "return", "!", "ARC_NAKED_P", "(", "fn_type", ")", ";", "}", "</s>" ]

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

[ "arc" ]

[]

[ "<s>", "void", "MipsSEFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "const", "MipsSEInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MipsSEInstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "const", "MipsRegisterInfo", "&", "RegInfo", "=", "*", "static_cast", "<", "const", "MipsRegisterInfo", "*", ">", "(", "STI", ".", "getRegisterInfo", "(", ")", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "MipsABIInfo", "ABI", "=", "STI", ".", "getABI", "(", ")", ";", "unsigned", "SP", "=", "ABI", ".", "GetStackPtr", "(", ")", ";", "unsigned", "FP", "=", "ABI", ".", "GetFramePtr", "(", ")", ";", "unsigned", "ZERO", "=", "ABI", ".", "GetNullPtr", "(", ")", ";", "unsigned", "MOVE", "=", "ABI", ".", "GetSPMoveOp", "(", ")", ";", "if", "(", "MFI", ".", "getStackSize", "(", ")", "==", "0", "&&", "!", "MFI", ".", "adjustsStack", "(", ")", ")", "return", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBBI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ";", "++", "i", ")", "--", "I", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "MOVE", ")", ",", "SP", ")", ".", "addReg", "(", "FP", ")", ".", "addReg", "(", "ZERO", ")", ";", "}", "if", "(", "MipsFI", "->", "callsEhReturn", "(", ")", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "ABI", ".", "ArePtrs64bit", "(", ")", "?", "&", "Mips", "::", "GPR64RegClass", ":", "&", "Mips", "::", "GPR32RegClass", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBBI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ";", "++", "i", ")", "--", "I", ";", "for", "(", "int", "J", "=", "0", ";", "J", "<", "4", ";", "++", "J", ")", "{", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "ABI", ".", "GetEhDataReg", "(", "J", ")", ",", "MipsFI", "->", "getEhDataRegFI", "(", "J", ")", ",", "RC", ",", "&", "RegInfo", ")", ";", "}", "}", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "emitInterruptEpilogueStub", "(", "MF", ",", "MBB", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "TII", ".", "adjustStackPtr", "(", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "0", "0", "Mips", "Mips::GPR64RegClass", "Mips::GPR32RegClass", "0", "0", "4", "Mips", "\"interrupt\"" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Lower il Copies\"", ";", "}", "</s>" ]

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

[ "R600", "\"SI Lower il Copies\"" ]

[]

[ "<s>", "bool", "symbolic_reference_mentioned_p", "(", "rtx", "op", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "op", ")", "==", "LABEL_REF", ")", "return", "true", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "op", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "op", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "op", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "symbolic_reference_mentioned_p", "(", "XVECEXP", "(", "op", ",", "i", ",", "j", ")", ")", ")", "return", "true", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "symbolic_reference_mentioned_p", "(", "XEXP", "(", "op", ",", "i", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "contains", "a", "symbol", "reference" ]

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

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"LEG DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "LEG", "\"LEG DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "static", "void", "mips_set_architecture", "(", "const", "struct", "mips_cpu_info", "*", "info", ")", "{", "if", "(", "info", "!=", "0", ")", "{", "mips_arch_info", "=", "info", ";", "mips_arch", "=", "info", "->", "cpu", ";", "mips_isa", "=", "info", "->", "isa", ";", "}", "}", "</s>" ]

[ "Set", "up", "globals", "to", "generate", "code", "for", "the", "ISA", "or", "processor", "described", "by", "INFO", "." ]

[ "mips", "0" ]

[]

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

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

[ "SIC", "SIC" ]

[]

[ "<s>", "void", "CSKYConstantPoolJT", "::", "print", "(", "raw_ostream", "&", "O", ")", "const", "{", "O", "<<", "\"JTI#\"", "<<", "JTI", ";", "CSKYConstantPoolValue", "::", "print", "(", "O", ")", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "\"JTI#\"", "CSKY" ]

[]

[ "<s>", "static", "bool", "frv_handle_option", "(", "size_t", "code", ",", "const", "char", "*", "arg", ",", "int", "value", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "code", ")", "{", "case", "OPT_mcpu_", ":", "if", "(", "strcmp", "(", "arg", ",", "\"simple\"", ")", "==", "0", ")", "frv_cpu_type", "=", "FRV_CPU_SIMPLE", ";", "else", "if", "(", "strcmp", "(", "arg", ",", "\"tomcat\"", ")", "==", "0", ")", "frv_cpu_type", "=", "FRV_CPU_TOMCAT", ";", "else", "if", "(", "strcmp", "(", "arg", ",", "\"fr550\"", ")", "==", "0", ")", "frv_cpu_type", "=", "FRV_CPU_FR550", ";", "else", "if", "(", "strcmp", "(", "arg", ",", "\"fr500\"", ")", "==", "0", ")", "frv_cpu_type", "=", "FRV_CPU_FR500", ";", "else", "if", "(", "strcmp", "(", "arg", ",", "\"fr450\"", ")", "==", "0", ")", "frv_cpu_type", "=", "FRV_CPU_FR450", ";", "else", "if", "(", "strcmp", "(", "arg", ",", "\"fr405\"", ")", "==", "0", ")", "frv_cpu_type", "=", "FRV_CPU_FR405", ";", "else", "if", "(", "strcmp", "(", "arg", ",", "\"fr400\"", ")", "==", "0", ")", "frv_cpu_type", "=", "FRV_CPU_FR400", ";", "else", "if", "(", "strcmp", "(", "arg", ",", "\"fr300\"", ")", "==", "0", ")", "frv_cpu_type", "=", "FRV_CPU_FR300", ";", "else", "if", "(", "strcmp", "(", "arg", ",", "\"frv\"", ")", "==", "0", ")", "frv_cpu_type", "=", "FRV_CPU_GENERIC", ";", "else", "return", "false", ";", "return", "true", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_HANDLE_OPTION", "." ]

[ "frv", "\"simple\"", "0", "\"tomcat\"", "0", "\"fr550\"", "0", "\"fr500\"", "0", "\"fr450\"", "0", "\"fr405\"", "0", "\"fr400\"", "0", "\"fr300\"", "0", "\"frv\"", "0" ]

[]

[ "<s>", "static", "bool", "aarch64_pragma_target_parse", "(", "tree", "args", ",", "tree", "pop_target", ")", "{", "if", "(", "args", ")", "{", "if", "(", "!", "aarch64_process_target_attr", "(", "args", ")", ")", "return", "false", ";", "aarch64_override_options_internal", "(", "&", "global_options", ")", ";", "}", "else", "{", "pop_target", "=", "pop_target", "?", "pop_target", ":", "target_option_default_node", ";", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_TARGET_OPTION", "(", "pop_target", ")", ")", ";", "}", "target_option_current_node", "=", "build_target_option_node", "(", "&", "global_options", ",", "&", "global_options_set", ")", ";", "aarch64_reset_previous_fndecl", "(", ")", ";", "cpp_options", "*", "cpp_opts", "=", "cpp_get_options", "(", "parse_in", ")", ";", "unsigned", "char", "saved_warn_unused_macros", "=", "cpp_opts", "->", "warn_unused_macros", ";", "cpp_opts", "->", "warn_unused_macros", "=", "0", ";", "cpp_force_token_locations", "(", "parse_in", ",", "BUILTINS_LOCATION", ")", ";", "aarch64_update_cpp_builtins", "(", "parse_in", ")", ";", "cpp_stop_forcing_token_locations", "(", "parse_in", ")", ";", "cpp_opts", "->", "warn_unused_macros", "=", "saved_warn_unused_macros", ";", "if", "(", "pop_target", ")", "aarch64_save_restore_target_globals", "(", "pop_target", ")", ";", "if", "(", "TARGET_SIMD", ")", "{", "tree", "saved_current_target_pragma", "=", "current_target_pragma", ";", "current_target_pragma", "=", "NULL", ";", "aarch64_init_simd_builtins", "(", ")", ";", "current_target_pragma", "=", "saved_current_target_pragma", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Hook", "to", "validate", "the", "current", "#", "pragma", "GCC", "target", "and", "set", "the", "state", ",", "and", "update", "the", "macros", "based", "on", "what", "was", "changed", ".", "If", "ARGS", "is", "NULL", ",", "then", "POP_TARGET", "is", "used", "to", "reset", "the", "options", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "void", "Cpu0FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "Cpu0FunctionInfo", "*", "Cpu0FI", "=", "MF", ".", "getInfo", "<", "Cpu0FunctionInfo", ">", "(", ")", ";", "const", "Cpu0InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Cpu0InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "SP", "=", "Cpu0", "::", "SP", ";", "unsigned", "FP", "=", "Cpu0", "::", "FP", ";", "unsigned", "ZERO", "=", "Cpu0", "::", "ZERO", ";", "unsigned", "ADDu", "=", "Cpu0", "::", "ADDu", ";", "unsigned", "ADDiu", "=", "Cpu0", "::", "ADDiu", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBBI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MFI", "->", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ";", "++", "i", ")", "--", "I", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "ADDu", ")", ",", "SP", ")", ".", "addReg", "(", "FP", ")", ".", "addReg", "(", "ZERO", ")", ";", "}", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "if", "(", "isInt", "<", "16", ">", "(", "StackSize", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ADDiu", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addImm", "(", "StackSize", ")", ";", "else", "{", "Cpu0FI", "->", "setEmitNOAT", "(", ")", ";", "expandLargeImm", "(", "SP", ",", "StackSize", ",", "TII", ",", "MBB", ",", "MBBI", ",", "dl", ")", ";", "}", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0::SP", "Cpu0::FP", "Cpu0::ZERO", "Cpu0::ADDu", "Cpu0::ADDiu", "0", "16", "Cpu0" ]

[]

[ "<s>", "static", "bool", "nds32_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "regno", ">", "FIRST_PSEUDO_REGISTER", ")", "return", "true", ";", "if", "(", "(", "TARGET_FPU_SINGLE", "||", "TARGET_FPU_DOUBLE", ")", "&&", "NDS32_IS_FPR_REGNUM", "(", "regno", ")", ")", "{", "if", "(", "NDS32_IS_EXT_FPR_REGNUM", "(", "regno", ")", ")", "return", "(", "NDS32_FPR_REGNO_OK_FOR_DOUBLE", "(", "regno", ")", "&&", "(", "mode", "==", "DFmode", ")", ")", ";", "else", "if", "(", "mode", "==", "SFmode", "||", "mode", "==", "SImode", ")", "return", "NDS32_FPR_REGNO_OK_FOR_SINGLE", "(", "regno", ")", ";", "else", "if", "(", "mode", "==", "DFmode", ")", "return", "NDS32_FPR_REGNO_OK_FOR_DOUBLE", "(", "regno", ")", ";", "return", "false", ";", "}", "if", "(", "regno", "<=", "NDS32_LAST_GPR_REGNUM", ")", "return", "(", "targetm", ".", "hard_regno_nregs", "(", "regno", ",", "mode", ")", "==", "1", "||", "!", "(", "(", "regno", ")", "&", "1", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", "." ]

[ "nds32", "1", "1" ]

[]

[ "<s>", "unsigned", "TeeRISCMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "getTeeRISCRegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "if", "(", "MO", ".", "isExpr", "(", ")", ")", "return", "0", ";", "errs", "(", ")", "<<", "MO", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "</s>" ]

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

[ "TeeRISC", "TeeRISC", "TeeRISC", "0", "0" ]

[]

[ "<s>", "static", "void", "nds32_emit_section_head_template", "(", "char", "section_name", "[", "]", ",", "char", "symbol_name", "[", "]", ",", "int", "align_value", ",", "bool", "object_p", ")", "{", "const", "char", "*", "flags_str", ";", "const", "char", "*", "type_str", ";", "flags_str", "=", "(", "object_p", ")", "?", "\"\\\"a\\\"\"", ":", "\"\\\"ax\\\"\"", ";", "type_str", "=", "(", "object_p", ")", "?", "\"@object\"", ":", "\"@function\"", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.section\\t%s, %s\\n\"", ",", "section_name", ",", "flags_str", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.align\\t%d\\n\"", ",", "align_value", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.global\\t%s\\n\"", ",", "symbol_name", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.type\\t%s, %s\\n\"", ",", "symbol_name", ",", "type_str", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"%s:\\n\"", ",", "symbol_name", ")", ";", "}", "</s>" ]

[ "A", "helper", "function", "to", "emit", "section", "head", "template", "." ]

[ "nds32", "\"\\\"a\\\"\"", "\"\\\"ax\\\"\"", "\"@object\"", "\"@function\"", "\"\\t.section\\t%s, %s\\n\"", "\"\\t.align\\t%d\\n\"", "\"\\t.global\\t%s\\n\"", "\"\\t.type\\t%s, %s\\n\"", "\"%s:\\n\"" ]

[]

[ "<s>", "static", "rtx", "nios2_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "CONSTANT_P", "(", "x", ")", ")", "return", "nios2_legitimize_constant_address", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST", ")", "{", "rtx", "unspec", ",", "offset", ";", "split_const", "(", "XEXP", "(", "x", ",", "1", ")", ",", "&", "unspec", ",", "&", "offset", ")", ";", "if", "(", "GET_CODE", "(", "unspec", ")", "==", "UNSPEC", "&&", "!", "nios2_large_offset_p", "(", "XINT", "(", "unspec", ",", "1", ")", ")", "&&", "offset", "!=", "const0_rtx", ")", "{", "rtx", "reg", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "unspec", "=", "copy_rtx", "(", "unspec", ")", ";", "XVECEXP", "(", "unspec", ",", "0", ",", "0", ")", "=", "plus_constant", "(", "Pmode", ",", "XVECEXP", "(", "unspec", ",", "0", ",", "0", ")", ",", "INTVAL", "(", "offset", ")", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "reg", ",", "gen_rtx_CONST", "(", "Pmode", ",", "unspec", ")", ")", ";", "}", "}", "return", "x", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMIZE_ADDRESS", "." ]

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

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"OpenRISC DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "OpenRISC", "\"OpenRISC DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "static", "void", "frv_start_packet", "(", "void", ")", "{", "enum", "frv_insn_group", "group", ";", "memset", "(", "frv_packet", ".", "regstate", ",", "0", ",", "sizeof", "(", "frv_packet", ".", "regstate", ")", ")", ";", "frv_packet", ".", "num_mems", "=", "0", ";", "frv_packet", ".", "num_insns", "=", "0", ";", "for", "(", "group", "=", "0", ";", "group", "<", "NUM_GROUPS", ";", "group", "++", ")", "frv_packet", ".", "groups", "[", "group", "]", ".", "num_insns", "=", "0", ";", "}", "</s>" ]

[ "Initialize", "frv_packet", "for", "the", "start", "of", "a", "new", "packet", "." ]

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

[]

[ "<s>", "OperandMatchResultTy", "AMDGPUAsmParser", "::", "tryParseRegister", "(", "unsigned", "&", "RegNo", ",", "SMLoc", "&", "StartLoc", ",", "SMLoc", "&", "EndLoc", ")", "{", "bool", "Result", "=", "ParseRegister", "(", "RegNo", ",", "StartLoc", ",", "EndLoc", ",", "true", ")", ";", "bool", "PendingErrors", "=", "getParser", "(", ")", ".", "hasPendingError", "(", ")", ";", "getParser", "(", ")", ".", "clearPendingErrors", "(", ")", ";", "if", "(", "PendingErrors", ")", "return", "MatchOperand_ParseFail", ";", "if", "(", "Result", ")", "return", "MatchOperand_NoMatch", ";", "return", "MatchOperand_Success", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "int", "c4x_check_laj_p", "(", "rtx", "insn", ")", "{", "insn", "=", "prev_nonnote_insn", "(", "insn", ")", ";", "if", "(", "insn", "==", "0", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CODE_LABEL", ")", "return", "1", ";", "if", "(", "c4x_r11_set_p", "(", "insn", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "The", "c4x", "sometimes", "has", "a", "problem", "when", "the", "insn", "before", "the", "laj", "insn", "sets", "the", "r11", "register", ".", "Check", "for", "this", "situation", "." ]

[ "c4x", "0", "0", "1", "1", "0" ]

[]

[ "<s>", "static", "bool", "frv_io_fixed_order_p", "(", "const", "struct", "frv_io", "*", "io1", ",", "const", "struct", "frv_io", "*", "io2", ")", "{", "if", "(", "io1", "->", "type", "==", "FRV_IO_WRITE", "&&", "io2", "->", "type", "==", "FRV_IO_WRITE", ")", "return", "true", ";", "if", "(", "io1", "->", "type", "!=", "FRV_IO_WRITE", "&&", "io2", "->", "type", "!=", "FRV_IO_WRITE", ")", "return", "false", ";", "return", "frv_same_doubleword_p", "(", "io1", ",", "io2", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "operations", "IO1", "and", "IO2", "are", "guaranteed", "to", "complete", "in", "order", "." ]

[ "frv" ]

[]

[ "<s>", "void", "X86DAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "OptForSize", "=", "MF", "->", "getFunction", "(", ")", "->", "optForSize", "(", ")", ";", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "SDNode", "*", "N", "=", "&", "*", "I", "++", ";", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "(", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", "&&", "!", "Subtarget", "->", "callRegIndirect", "(", ")", ")", "||", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "TC_RETURN", "&&", "(", "Subtarget", "->", "is64Bit", "(", ")", "||", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", ")", ")", ")", "{", "bool", "HasCallSeq", "=", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", ";", "SDValue", "Chain", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Load", "=", "N", "->", "getOperand", "(", "1", ")", ";", "if", "(", "!", "isCalleeLoad", "(", "Load", ",", "Chain", ",", "HasCallSeq", ")", ")", "continue", ";", "moveBelowOrigChain", "(", "CurDAG", ",", "Load", ",", "SDValue", "(", "N", ",", "0", ")", ",", "Chain", ")", ";", "++", "NumLoadMoved", ";", "continue", ";", "}", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_ROUND", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "MVT", "SrcVT", "=", "N", "->", "getOperand", "(", "0", ")", ".", "getSimpleValueType", "(", ")", ";", "MVT", "DstVT", "=", "N", "->", "getSimpleValueType", "(", "0", ")", ";", "if", "(", "SrcVT", ".", "isVector", "(", ")", "||", "DstVT", ".", "isVector", "(", ")", ")", "continue", ";", "const", "X86TargetLowering", "*", "X86Lowering", "=", "static_cast", "<", "const", "X86TargetLowering", "*", ">", "(", "TLI", ")", ";", "bool", "SrcIsSSE", "=", "X86Lowering", "->", "isScalarFPTypeInSSEReg", "(", "SrcVT", ")", ";", "bool", "DstIsSSE", "=", "X86Lowering", "->", "isScalarFPTypeInSSEReg", "(", "DstVT", ")", ";", "if", "(", "SrcIsSSE", "&&", "DstIsSSE", ")", "continue", ";", "if", "(", "!", "SrcIsSSE", "&&", "!", "DstIsSSE", ")", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "if", "(", "N", "->", "getConstantOperandVal", "(", "1", ")", ")", "continue", ";", "}", "MVT", "MemVT", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_ROUND", ")", "MemVT", "=", "DstVT", ";", "else", "MemVT", "=", "SrcIsSSE", "?", "SrcVT", ":", "DstVT", ";", "SDValue", "MemTmp", "=", "CurDAG", "->", "CreateStackTemporary", "(", "MemVT", ")", ";", "SDLoc", "dl", "(", "N", ")", ";", "SDValue", "Store", "=", "CurDAG", "->", "getTruncStore", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "dl", ",", "N", "->", "getOperand", "(", "0", ")", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ",", "false", ",", "false", ",", "0", ")", ";", "SDValue", "Result", "=", "CurDAG", "->", "getExtLoad", "(", "ISD", "::", "EXTLOAD", ",", "dl", ",", "DstVT", ",", "Store", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ",", "false", ",", "false", ",", "false", ",", "0", ")", ";", "--", "I", ";", "CurDAG", "->", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "0", ")", ",", "Result", ")", ";", "++", "I", ";", "CurDAG", "->", "DeleteNode", "(", "N", ")", ";", "}", "}", "</s>" ]

[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]

[ "X86", "X86", "X86ISD::CALL", "X86ISD::TC_RETURN", "X86ISD::CALL", "0", "1", "0", "ISD::FP_ROUND", "ISD::FP_EXTEND", "0", "0", "X86", "X86", "X86", "X86", "X86", "ISD::FP_EXTEND", "1", "ISD::FP_ROUND", "0", "0", "ISD::EXTLOAD", "0", "0" ]

[]

[ "<s>", "MachineBasicBlock", "*", "getHeader", "(", ")", "const", "override", "{", "return", "Unit", "->", "getHeader", "(", ")", ";", "}", "</s>" ]

[ "The", "header", "is", "the", "entry", "for", "each", "iteration", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "bool", "M68kRegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "!", "TargetRegisterInfo", "::", "canRealignStack", "(", "MF", ")", ")", "return", "false", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "!", "MRI", "->", "canReserveReg", "(", "FramePtr", ")", ")", "return", "false", ";", "if", "(", "CantUseSP", "(", "MFI", ")", ")", "return", "MRI", "->", "canReserveReg", "(", "BasePtr", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "True", "if", "the", "stack", "can", "be", "realigned", "for", "the", "target", "." ]

[ "M68k", "M68k" ]

[]

[ "<s>", "static", "bool", "class_can_hold_mode", "(", "reg_class_t", "rclass", ",", "machine_mode", "mode", ")", "{", "static", "char", "results", "[", "LIM_REG_CLASSES", "]", "[", "MAX_MACHINE_MODE", "]", ";", "if", "(", "results", "[", "(", "int", ")", "rclass", "]", "[", "mode", "]", "==", "0", ")", "{", "int", "r", ";", "results", "[", "rclass", "]", "[", "mode", "]", "=", "1", ";", "for", "(", "r", "=", "0", ";", "r", "<", "FIRST_PSEUDO_REGISTER", ";", "r", "++", ")", "if", "(", "in_hard_reg_set_p", "(", "reg_class_contents", "[", "(", "int", ")", "rclass", "]", ",", "mode", ",", "r", ")", "&&", "m32c_hard_regno_mode_ok", "(", "r", ",", "mode", ")", ")", "{", "results", "[", "rclass", "]", "[", "mode", "]", "=", "2", ";", "break", ";", "}", "}", "fprintf", "(", "stderr", ",", "\"class %s can hold %s? %s\\n\"", ",", "class_names", "[", "(", "int", ")", "rclass", "]", ",", "mode_name", "[", "mode", "]", ",", "(", "results", "[", "rclass", "]", "[", "mode", "]", "==", "2", ")", "?", "\"yes\"", ":", "\"no\"", ")", ";", "return", "results", "[", "(", "int", ")", "rclass", "]", "[", "mode", "]", "==", "2", ";", "}", "</s>" ]

[ "Used", "by", "m32c_register_move_cost", "to", "determine", "if", "a", "move", "is", "impossibly", "expensive", "." ]

[ "m32c", "0", "1", "0", "2", "\"class %s can hold %s? %s\\n\"", "2", "\"yes\"", "\"no\"", "2" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "shouldScheduleLoadsNear", "(", "SDNode", "*", "Load1", ",", "SDNode", "*", "Load2", ",", "int64_t", "Offset1", ",", "int64_t", "Offset2", ",", "unsigned", "NumLoads", ")", "const", "{", "assert", "(", "Offset2", ">", "Offset1", ")", ";", "if", "(", "(", "Offset2", "-", "Offset1", ")", "/", "8", ">", "64", ")", "return", "false", ";", "unsigned", "Opc1", "=", "Load1", "->", "getMachineOpcode", "(", ")", ";", "unsigned", "Opc2", "=", "Load2", "->", "getMachineOpcode", "(", ")", ";", "if", "(", "Opc1", "!=", "Opc2", ")", "return", "false", ";", "switch", "(", "Opc1", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "LD_Fp32m", ":", "case", "X86", "::", "LD_Fp64m", ":", "case", "X86", "::", "LD_Fp80m", ":", "case", "X86", "::", "MMX_MOVD64rm", ":", "case", "X86", "::", "MMX_MOVQ64rm", ":", "return", "false", ";", "}", "EVT", "VT", "=", "Load1", "->", "getValueType", "(", "0", ")", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "{", "if", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "is64Bit", "(", ")", ")", "{", "if", "(", "NumLoads", ">=", "3", ")", "return", "false", ";", "}", "else", "if", "(", "NumLoads", ")", "return", "false", ";", "break", ";", "}", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i64", ":", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "if", "(", "NumLoads", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "shouldScheduleLoadsNear", "-", "This", "is", "a", "used", "by", "the", "pre-regalloc", "scheduler", "to", "determine", "(", "in", "conjunction", "with", "areLoadsFromSameBasePtr", ")", "if", "two", "loads", "should", "be", "scheduled", "togther", "." ]

[ "X86", "X86", "8", "64", "X86::LD_Fp32m", "X86::LD_Fp64m", "X86::LD_Fp80m", "X86::MMX_MOVD64rm", "X86::MMX_MOVQ64rm", "0", "3", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::i64", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "SparcTargetMachine", "::", "SparcTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "is64bit", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ")", ",", "Subtarget", "(", "TT", ",", "FS", ",", "is64bit", ")", ",", "DataLayout", "(", "Subtarget", ".", "getDataLayout", "(", ")", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "TSInfo", "(", "*", "this", ")", ",", "InstrInfo", "(", "Subtarget", ")", ",", "FrameLowering", "(", "Subtarget", ")", "{", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc" ]

[]

[ "<s>", "static", "rtx", "aarch64_gen_compare_reg_maybe_ze", "(", "RTX_CODE", "code", ",", "rtx", "x", ",", "rtx", "y", ",", "machine_mode", "y_mode", ")", "{", "if", "(", "y_mode", "==", "E_QImode", "||", "y_mode", "==", "E_HImode", ")", "{", "if", "(", "CONST_INT_P", "(", "y", ")", ")", "{", "y", "=", "GEN_INT", "(", "INTVAL", "(", "y", ")", "&", "GET_MODE_MASK", "(", "y_mode", ")", ")", ";", "y_mode", "=", "SImode", ";", "}", "else", "{", "rtx", "t", ",", "cc_reg", ";", "machine_mode", "cc_mode", ";", "t", "=", "gen_rtx_ZERO_EXTEND", "(", "SImode", ",", "y", ")", ";", "t", "=", "gen_rtx_COMPARE", "(", "CC_SWPmode", ",", "t", ",", "x", ")", ";", "cc_mode", "=", "CC_SWPmode", ";", "cc_reg", "=", "gen_rtx_REG", "(", "cc_mode", ",", "CC_REGNUM", ")", ";", "emit_set_insn", "(", "cc_reg", ",", "t", ")", ";", "return", "cc_reg", ";", "}", "}", "if", "(", "!", "aarch64_plus_operand", "(", "y", ",", "y_mode", ")", ")", "y", "=", "force_reg", "(", "y_mode", ",", "y", ")", ";", "return", "aarch64_gen_compare_reg", "(", "code", ",", "x", ",", "y", ")", ";", "}", "</s>" ]

[ "Similarly", ",", "but", "maybe", "zero-extend", "Y", "if", "Y_MODE", "<", "SImode", "." ]

[ "aarch64" ]

[]

[ "<s>", "int", "arc_address_cost", "(", "rtx", "addr", ",", "machine_mode", ",", "addr_space_t", ",", "bool", "speed", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "return", "speed", "||", "satisfies_constraint_Rcq", "(", "addr", ")", "?", "0", ":", "1", ";", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "case", "POST_INC", ":", "case", "POST_DEC", ":", "case", "PRE_MODIFY", ":", "case", "POST_MODIFY", ":", "return", "!", "speed", ";", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "case", "CONST", ":", "return", "COSTS_N_INSNS", "(", "1", ")", ";", "case", "PLUS", ":", "{", "register", "rtx", "plus0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "register", "rtx", "plus1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "plus0", ")", "!=", "REG", "&&", "(", "GET_CODE", "(", "plus0", ")", "!=", "MULT", "||", "!", "CONST_INT_P", "(", "XEXP", "(", "plus0", ",", "1", ")", ")", "||", "(", "INTVAL", "(", "XEXP", "(", "plus0", ",", "1", ")", ")", "!=", "2", "&&", "INTVAL", "(", "XEXP", "(", "plus0", ",", "1", ")", ")", "!=", "4", ")", ")", ")", "break", ";", "switch", "(", "GET_CODE", "(", "plus1", ")", ")", "{", "case", "CONST_INT", ":", "return", "(", "!", "RTX_OK_FOR_OFFSET_P", "(", "SImode", ",", "plus1", ")", "?", "COSTS_N_INSNS", "(", "1", ")", ":", "speed", "?", "0", ":", "(", "satisfies_constraint_Rcq", "(", "plus0", ")", "&&", "satisfies_constraint_O", "(", "plus1", ")", ")", "?", "0", ":", "1", ")", ";", "case", "REG", ":", "return", "(", "speed", "<", "1", "?", "0", ":", "(", "satisfies_constraint_Rcq", "(", "plus0", ")", "&&", "satisfies_constraint_Rcq", "(", "plus1", ")", ")", "?", "0", ":", "1", ")", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "COSTS_N_INSNS", "(", "1", ")", ";", "default", ":", "break", ";", "}", "break", ";", "}", "default", ":", "break", ";", "}", "return", "4", ";", "}", "</s>" ]

[ "Provide", "the", "costs", "of", "an", "addressing", "mode", "that", "contains", "ADDR", ".", "If", "ADDR", "is", "not", "a", "valid", "address", ",", "its", "cost", "is", "irrelevant", "." ]

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

[]

[ "<s>", "static", "void", "gen_one_bundle", "(", "rtx_insn", "*", "*", "slot", ",", "int", "n_filled", ",", "int", "real_first", ")", "{", "rtx", "seq", ";", "rtx_insn", "*", "bundle", ";", "rtx_insn", "*", "t", ";", "int", "i", ";", "seq", "=", "gen_rtx_SEQUENCE", "(", "VOIDmode", ",", "gen_rtvec_v", "(", "n_filled", ",", "slot", ")", ")", ";", "bundle", "=", "make_insn_raw", "(", "seq", ")", ";", "BLOCK_FOR_INSN", "(", "bundle", ")", "=", "BLOCK_FOR_INSN", "(", "slot", "[", "0", "]", ")", ";", "INSN_LOCATION", "(", "bundle", ")", "=", "INSN_LOCATION", "(", "slot", "[", "0", "]", ")", ";", "SET_PREV_INSN", "(", "bundle", ")", "=", "SET_PREV_INSN", "(", "slot", "[", "real_first", "]", ")", ";", "t", "=", "NULL", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_filled", ";", "i", "++", ")", "{", "rtx_insn", "*", "insn", "=", "slot", "[", "i", "]", ";", "remove_insn", "(", "insn", ")", ";", "SET_PREV_INSN", "(", "insn", ")", "=", "t", "?", "t", ":", "PREV_INSN", "(", "bundle", ")", ";", "if", "(", "t", "!=", "NULL_RTX", ")", "SET_NEXT_INSN", "(", "t", ")", "=", "insn", ";", "t", "=", "insn", ";", "if", "(", "i", ">", "0", ")", "INSN_LOCATION", "(", "slot", "[", "i", "]", ")", "=", "INSN_LOCATION", "(", "bundle", ")", ";", "}", "SET_NEXT_INSN", "(", "bundle", ")", "=", "NEXT_INSN", "(", "PREV_INSN", "(", "bundle", ")", ")", ";", "SET_NEXT_INSN", "(", "t", ")", "=", "NEXT_INSN", "(", "bundle", ")", ";", "SET_NEXT_INSN", "(", "PREV_INSN", "(", "bundle", ")", ")", "=", "bundle", ";", "SET_PREV_INSN", "(", "NEXT_INSN", "(", "bundle", ")", ")", "=", "bundle", ";", "}", "</s>" ]

[ "Create", "a", "SEQUENCE", "rtx", "to", "replace", "the", "instructions", "in", "SLOT", ",", "of", "which", "there", "are", "N_FILLED", ".", "REAL_FIRST", "identifies", "the", "slot", "if", "the", "insn", "that", "appears", "first", "in", "the", "original", "stream", "." ]

[ "c6x", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"unexpected inline asm memory operand\"", ")", ";", "O", "<<", "\"[\"", "<<", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "\"]\"", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "\"unexpected inline asm memory operand\"", "\"[\"", "\"]\"" ]

[]

[ "<s>", "void", "RISCVDAGToDAGISel", "::", "PostprocessISelDAG", "(", ")", "{", "doPeepholeLoadStoreOffset", "(", ")", ";", "}", "</s>" ]

[ "PostprocessISelDAG", "(", ")", "-", "This", "hook", "allows", "the", "target", "to", "hack", "on", "the", "graph", "right", "after", "selection", "." ]

[ "RISCV", "RISCV" ]

[]

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

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

[ "arm", "0", "\"target CPU does not support THUMB instructions\"", "0", "0", "1", "0", "\"target CPU does not support unaligned accesses\"", "0", "0", "0", "\"incompatible options %<-mstack-protector-guard=global%> and \"", "\"%<-mstack-protector-guard-offset=%s%>\"", "0", "0", "\"%qs is not a valid offset in %qs\"", "\"-mstack-protector-guard-offset=\"" ]

[]

[ "<s>", "void", "LanaiPassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "createLanaiMemAluCombinerPass", "(", ")", ")", ";", "addPass", "(", "createLanaiSetflagAluCombinerPass", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai", "Lanai" ]

[]

[ "<s>", "void", "Thumb1RegisterInfo", "::", "emitLoadConstPool", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "DebugLoc", "dl", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "int", "Val", ",", "ARMCC", "::", "CondCodes", "Pred", ",", "unsigned", "PredReg", ",", "unsigned", "MIFlags", ")", "const", "{", "assert", "(", "(", "isARMLowRegister", "(", "DestReg", ")", "||", "isVirtualRegister", "(", "DestReg", ")", ")", "&&", "\"Thumb1 does not have ldr to high register\"", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "MachineConstantPool", "*", "ConstantPool", "=", "MF", ".", "getConstantPool", "(", ")", ";", "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "Val", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tLDRpci", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ",", "SubIdx", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addImm", "(", "Pred", ")", ".", "addReg", "(", "PredReg", ")", ".", "setMIFlags", "(", "MIFlags", ")", ";", "}", "</s>" ]

[ "emitLoadConstPool", "-", "Emits", "a", "load", "from", "constpool", "to", "materialize", "the", "specified", "immediate", "." ]

[ "ARM", "ARMCC::CondCodes", "ARM", "\"Thumb1 does not have ldr to high register\"", "4", "ARM::tLDRpci" ]

[]

[ "<s>", "bool", "MCS51AsmParser", "::", "ParseDirective", "(", "llvm", "::", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", ".", "lower", "(", ")", "==", "\".long\"", ")", "{", "parseLiteralValues", "(", "SIZE_LONG", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "}", "else", "if", "(", "IDVal", ".", "lower", "(", ")", "==", "\".word\"", "||", "IDVal", ".", "lower", "(", ")", "==", "\".short\"", ")", "{", "parseLiteralValues", "(", "SIZE_WORD", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "}", "else", "if", "(", "IDVal", ".", "lower", "(", ")", "==", "\".byte\"", ")", "{", "parseLiteralValues", "(", "1", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51", "\".long\"", "\".word\"", "\".short\"", "\".byte\"", "1" ]

[]

[ "<s>", "void", "AVRInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "AVR", "::", "LDRdPtr", ":", "case", "AVR", "::", "LDRdPtrPi", ":", "case", "AVR", "::", "LDRdPtrPd", ":", "O", "<<", "\"\\tld\\t\"", ";", "printOperand", "(", "MI", ",", "0", ",", "O", ")", ";", "O", "<<", "\", \"", ";", "if", "(", "Opcode", "==", "AVR", "::", "LDRdPtrPd", ")", "O", "<<", "'-'", ";", "printOperand", "(", "MI", ",", "1", ",", "O", ")", ";", "if", "(", "Opcode", "==", "AVR", "::", "LDRdPtrPi", ")", "O", "<<", "'+'", ";", "break", ";", "case", "AVR", "::", "STPtrRr", ":", "O", "<<", "\"\\tst\\t\"", ";", "printOperand", "(", "MI", ",", "0", ",", "O", ")", ";", "O", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "1", ",", "O", ")", ";", "break", ";", "case", "AVR", "::", "STPtrPiRr", ":", "case", "AVR", "::", "STPtrPdRr", ":", "O", "<<", "\"\\tst\\t\"", ";", "if", "(", "Opcode", "==", "AVR", "::", "STPtrPdRr", ")", "O", "<<", "'-'", ";", "printOperand", "(", "MI", ",", "1", ",", "O", ")", ";", "if", "(", "Opcode", "==", "AVR", "::", "STPtrPiRr", ")", "O", "<<", "'+'", ";", "O", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "2", ",", "O", ")", ";", "break", ";", "default", ":", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "break", ";", "}", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR::LDRdPtr", "AVR::LDRdPtrPi", "AVR::LDRdPtrPd", "\"\\tld\\t\"", "0", "\", \"", "AVR::LDRdPtrPd", "1", "AVR::LDRdPtrPi", "AVR::STPtrRr", "\"\\tst\\t\"", "0", "\", \"", "1", "AVR::STPtrPiRr", "AVR::STPtrPdRr", "\"\\tst\\t\"", "AVR::STPtrPdRr", "1", "AVR::STPtrPiRr", "\", \"", "2" ]

[]

[ "<s>", "void", "NVPTXInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "unsigned", "RCId", "=", "(", "RegNo", ">>", "28", ")", ";", "switch", "(", "RCId", ")", "{", "default", ":", "report_fatal_error", "(", "\"Bad virtual register encoding\"", ")", ";", "case", "0", ":", "OS", "<<", "getRegisterName", "(", "RegNo", ")", ";", "return", ";", "case", "1", ":", "OS", "<<", "\"%p\"", ";", "break", ";", "case", "2", ":", "OS", "<<", "\"%rs\"", ";", "break", ";", "case", "3", ":", "OS", "<<", "\"%r\"", ";", "break", ";", "case", "4", ":", "OS", "<<", "\"%rd\"", ";", "break", ";", "case", "5", ":", "OS", "<<", "\"%f\"", ";", "break", ";", "case", "6", ":", "OS", "<<", "\"%fd\"", ";", "break", ";", "case", "7", ":", "OS", "<<", "\"%h\"", ";", "break", ";", "}", "unsigned", "VReg", "=", "RegNo", "&", "0x0FFFFFFF", ";", "OS", "<<", "VReg", ";", "}", "</s>" ]

[ "Print", "the", "assembler", "register", "name", "." ]

[ "NVPTX", "NVPTX", "28", "\"Bad virtual register encoding\"", "0", "1", "\"%p\"", "2", "\"%rs\"", "3", "\"%r\"", "4", "\"%rd\"", "5", "\"%f\"", "6", "\"%fd\"", "7", "\"%h\"", "0x0FFFFFFF" ]

[]

[ "<s>", "int", "rl78_far_p", "(", "rtx", "x", ")", "{", "if", "(", "!", "MEM_P", "(", "x", ")", ")", "return", "0", ";", "fprintf", "(", "stderr", ",", "\"\\033[35mrl78_far_p: \"", ")", ";", "debug_rtx", "(", "x", ")", ";", "fprintf", "(", "stderr", ",", "\" = %d\\033[0m\\n\"", ",", "MEM_ADDR_SPACE", "(", "x", ")", "==", "ADDR_SPACE_FAR", ")", ";", "if", "(", "!", "rl78_as_legitimate_address", "(", "GET_MODE", "(", "x", ")", ",", "XEXP", "(", "x", ",", "0", ")", ",", "false", ",", "ADDR_SPACE_FAR", ")", ")", "return", "0", ";", "return", "GET_MODE_BITSIZE", "(", "rl78_addr_space_address_mode", "(", "MEM_ADDR_SPACE", "(", "x", ")", ")", ")", "==", "32", ";", "}", "</s>" ]

[ "Used", "in", "various", "constraints", "and", "predicates", "to", "match", "operands", "in", "the", "``", "far", "''", "address", "space", "." ]

[ "rl78", "0", "\"\\033[35mrl78_far_p: \"", "\" = %d\\033[0m\\n\"", "0", "0", "32" ]

[]

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

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

[ "Mips", "\"CHERI invalidate pass\"" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"HSAIL Always Inline Pass\"", ";", "}", "</s>" ]

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

[ "HSAIL", "\"HSAIL Always Inline Pass\"" ]

[]

[ "<s>", "MCOperand", "SystemZMCInstLower", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "case", "MachineOperand", "::", "MO_Register", ":", "return", "MCOperand", "::", "CreateReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "return", "MCOperand", "::", "CreateImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "default", ":", "{", "MCSymbolRefExpr", "::", "VariantKind", "Kind", "=", "getVariantKind", "(", "MO", ".", "getTargetFlags", "(", ")", ")", ";", "return", "MCOperand", "::", "CreateExpr", "(", "getExpr", "(", "MO", ",", "Kind", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "void", "fma_forest", "::", "dispatch", "(", ")", "{", "this", "->", "m_target_parity", "=", "this", "->", "m_roots", "->", "front", "(", ")", "->", "get_parity", "(", ")", ";", "int", "fpu_balance", "=", "this", "->", "m_globals", "->", "get_fpu_balance", "(", ")", ";", "if", "(", "fpu_balance", "!=", "0", ")", "this", "->", "m_target_parity", "=", "(", "fpu_balance", "<", "0", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Target parity for forest #%d: %s\\n\"", ",", "this", "->", "m_id", ",", "this", "->", "m_target_parity", "?", "\"odd\"", ":", "\"even\"", ")", ";", "}", "</s>" ]

[ "Dispatch", "forest", "to", "the", "least", "utilized", "pipeline", "." ]

[ "aarch64", "0", "0", "\"Target parity for forest #%d: %s\\n\"", "\"odd\"", "\"even\"" ]

[]

[ "<s>", "static", "bool", "loongarch_scalar_mode_supported_p", "(", "scalar_mode", "mode", ")", "{", "if", "(", "ALL_FIXED_POINT_MODE_P", "(", "mode", ")", "&&", "GET_MODE_PRECISION", "(", "mode", ")", "<=", "2", "*", "BITS_PER_WORD", ")", "return", "true", ";", "return", "default_scalar_mode_supported_p", "(", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCALAR_MODE_SUPPORTED_P", "." ]

[ "loongarch", "2" ]

[]

[ "<s>", "machreg_t", "inet_ntoa", "(", "machreg_t", "in", ")", "{", "return", "_inet_ntoa", "(", "in", "<<", "SHIFT_BITS", ")", ";", "}", "</s>" ]

[ "<", "arpa/inet.h", ">", "has", "char", "*", "inet_ntoa", "(", "struct", "in_addr", ")", ";", "on", "both", "IRIX", "6.2", "and", "6.5", ",", "with", "struct", "in_addr", "containing", "a", "32-bit", "int", "." ]

[ "mips" ]

[]

[ "<s>", "unsigned", "LanaiMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCOperand", "&", "MCOp", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "SubtargetInfo", ")", "const", "{", "if", "(", "MCOp", ".", "isReg", "(", ")", ")", "return", "getLanaiRegisterNumbering", "(", "MCOp", ".", "getReg", "(", ")", ")", ";", "if", "(", "MCOp", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MCOp", ".", "getImm", "(", ")", ")", ";", "assert", "(", "MCOp", ".", "isExpr", "(", ")", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MCOp", ".", "getExpr", "(", ")", ";", "if", "(", "Expr", "->", "getKind", "(", ")", "==", "MCExpr", "::", "Binary", ")", "{", "const", "MCBinaryExpr", "*", "BinaryExpr", "=", "static_cast", "<", "const", "MCBinaryExpr", "*", ">", "(", "Expr", ")", ";", "Expr", "=", "BinaryExpr", "->", "getLHS", "(", ")", ";", "}", "assert", "(", "isa", "<", "LanaiMCExpr", ">", "(", "Expr", ")", "||", "Expr", "->", "getKind", "(", ")", "==", "MCExpr", "::", "SymbolRef", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "MCOp", ".", "getExpr", "(", ")", ",", "MCFixupKind", "(", "FixupKind", "(", "Expr", ")", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai", "Lanai", "0", "0" ]

[]

[ "<s>", "bool", "Z80oldTargetLowering", "::", "IsDesirableToPromoteOp", "(", "SDValue", "Op", ",", "EVT", "&", "PVT", ")", "const", "{", "if", "(", "isDesirableToShrinkOp", "(", "Op", ".", "getOpcode", "(", ")", ",", "MVT", "::", "i24", ",", "Op", ".", "getValueType", "(", ")", ")", ")", "{", "return", "false", ";", "}", "PVT", "=", "MVT", "::", "i24", ";", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "has", "native", "support", "for", "the", "specified", "value", "type", "and", "it", "is", "'desirable", "'", "to", "use", "the", "type", "." ]

[ "Z80old", "Z80old", "MVT::i24", "MVT::i24" ]

[]

[ "<s>", "static", "unsigned", "int", "mips_global_pointer", "(", "void", ")", "{", "unsigned", "int", "regno", ";", "if", "(", "!", "TARGET_USE_GOT", ")", "return", "GLOBAL_POINTER_REGNUM", ";", "if", "(", "mips_cfun_has_inflexible_gp_ref_p", "(", ")", ")", "return", "GLOBAL_POINTER_REGNUM", ";", "if", "(", "TARGET_ABSOLUTE_JUMPS", "&&", "!", "mips_cfun_has_flexible_gp_ref_p", "(", ")", ")", "return", "INVALID_REGNUM", ";", "if", "(", "TARGET_CALL_SAVED_GP", "&&", "crtl", "->", "is_leaf", ")", "for", "(", "regno", "=", "GP_REG_FIRST", ";", "regno", "<=", "GP_REG_LAST", ";", "regno", "++", ")", "if", "(", "!", "df_regs_ever_live_p", "(", "regno", ")", "&&", "call_used_regs", "[", "regno", "]", "&&", "!", "fixed_regs", "[", "regno", "]", "&&", "regno", "!=", "PIC_FUNCTION_ADDR_REGNUM", ")", "return", "regno", ";", "return", "GLOBAL_POINTER_REGNUM", ";", "}", "</s>" ]

[ "Return", "the", "register", "that", "should", "be", "used", "as", "the", "global", "pointer", "within", "this", "function", ".", "Return", "0", "if", "the", "function", "does", "n't", "need", "a", "global", "pointer", "." ]

[ "mips" ]

[]

[ "<s>", "static", "void", "emit_unlikely_jump", "(", "rtx", "insn", ")", "{", "rtx_insn", "*", "jump", "=", "emit_jump_insn", "(", "insn", ")", ";", "add_reg_br_prob_note", "(", "jump", ",", "profile_probability", "::", "very_unlikely", "(", ")", ")", ";", "}", "</s>" ]

[ "Mark", "the", "previous", "jump", "instruction", "as", "unlikely", "." ]

[ "arc" ]

[]

[ "<s>", "static", "bool", "predicate_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "cond", ",", "bool", "doit", ")", "{", "int", "icode", ";", "if", "(", "cond", "==", "NULL_RTX", ")", "{", "gcc_assert", "(", "!", "doit", ")", ";", "return", "false", ";", "}", "if", "(", "get_attr_predicable", "(", "insn", ")", "==", "PREDICABLE_YES", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "COND_EXEC", ")", "{", "if", "(", "doit", ")", "{", "rtx", "newpat", "=", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "cond", ",", "PATTERN", "(", "insn", ")", ")", ";", "PATTERN", "(", "insn", ")", "=", "newpat", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "}", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "COND_EXEC", "&&", "rtx_equal_p", "(", "COND_EXEC_TEST", "(", "PATTERN", "(", "insn", ")", ")", ",", "cond", ")", ")", "return", "true", ";", "icode", "=", "INSN_CODE", "(", "insn", ")", ";", "if", "(", "icode", "==", "CODE_FOR_real_jump", "||", "icode", "==", "CODE_FOR_jump", "||", "icode", "==", "CODE_FOR_indirect_jump", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "dest", "=", "(", "icode", "==", "CODE_FOR_real_jump", "?", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ":", "icode", "==", "CODE_FOR_jump", "?", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "0", ")", ":", "SET_SRC", "(", "pat", ")", ")", ";", "if", "(", "doit", ")", "{", "rtx", "newpat", ";", "if", "(", "REG_P", "(", "dest", ")", ")", "newpat", "=", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "cond", ",", "PATTERN", "(", "insn", ")", ")", ";", "else", "newpat", "=", "gen_br_true", "(", "cond", ",", "XEXP", "(", "cond", ",", "0", ")", ",", "dest", ")", ";", "PATTERN", "(", "insn", ")", "=", "newpat", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "}", "return", "true", ";", "}", "if", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_br_true", ")", "{", "rtx", "br_cond", "=", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ",", "0", ")", ";", "return", "rtx_equal_p", "(", "br_cond", ",", "cond", ")", ";", "}", "if", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_br_false", ")", "{", "rtx", "br_cond", "=", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ",", "0", ")", ";", "return", "conditions_opposite_p", "(", "br_cond", ",", "cond", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "can", "add", "a", "predicate", "COND", "to", "INSN", ",", "or", "if", "INSN", "already", "has", "that", "predicate", ".", "If", "DOIT", "is", "true", ",", "also", "perform", "the", "modification", "." ]

[ "c6x", "1", "0", "0", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "void", "nvptx_generate_vector_shuffle", "(", "location_t", "loc", ",", "tree", "dest_var", ",", "tree", "var", ",", "unsigned", "shift", ",", "gimple_seq", "*", "seq", ")", "{", "unsigned", "fn", "=", "NVPTX_BUILTIN_SHUFFLE", ";", "tree_code", "code", "=", "NOP_EXPR", ";", "tree", "arg_type", "=", "unsigned_type_node", ";", "tree", "var_type", "=", "TREE_TYPE", "(", "var", ")", ";", "tree", "dest_type", "=", "var_type", ";", "if", "(", "TREE_CODE", "(", "var_type", ")", "==", "COMPLEX_TYPE", ")", "var_type", "=", "TREE_TYPE", "(", "var_type", ")", ";", "if", "(", "TREE_CODE", "(", "var_type", ")", "==", "REAL_TYPE", ")", "code", "=", "VIEW_CONVERT_EXPR", ";", "if", "(", "TYPE_SIZE", "(", "var_type", ")", "==", "TYPE_SIZE", "(", "long_long_unsigned_type_node", ")", ")", "{", "fn", "=", "NVPTX_BUILTIN_SHUFFLELL", ";", "arg_type", "=", "long_long_unsigned_type_node", ";", "}", "tree", "call", "=", "nvptx_builtin_decl", "(", "fn", ",", "true", ")", ";", "tree", "bits", "=", "build_int_cst", "(", "unsigned_type_node", ",", "shift", ")", ";", "tree", "kind", "=", "build_int_cst", "(", "unsigned_type_node", ",", "SHUFFLE_DOWN", ")", ";", "tree", "expr", ";", "if", "(", "var_type", "!=", "dest_type", ")", "{", "tree", "real", "=", "fold_build1", "(", "REALPART_EXPR", ",", "var_type", ",", "var", ")", ";", "real", "=", "fold_build1", "(", "code", ",", "arg_type", ",", "real", ")", ";", "real", "=", "build_call_expr_loc", "(", "loc", ",", "call", ",", "3", ",", "real", ",", "bits", ",", "kind", ")", ";", "real", "=", "fold_build1", "(", "code", ",", "var_type", ",", "real", ")", ";", "tree", "imag", "=", "fold_build1", "(", "IMAGPART_EXPR", ",", "var_type", ",", "var", ")", ";", "imag", "=", "fold_build1", "(", "code", ",", "arg_type", ",", "imag", ")", ";", "imag", "=", "build_call_expr_loc", "(", "loc", ",", "call", ",", "3", ",", "imag", ",", "bits", ",", "kind", ")", ";", "imag", "=", "fold_build1", "(", "code", ",", "var_type", ",", "imag", ")", ";", "expr", "=", "fold_build2", "(", "COMPLEX_EXPR", ",", "dest_type", ",", "real", ",", "imag", ")", ";", "}", "else", "{", "expr", "=", "fold_build1", "(", "code", ",", "arg_type", ",", "var", ")", ";", "expr", "=", "build_call_expr_loc", "(", "loc", ",", "call", ",", "3", ",", "expr", ",", "bits", ",", "kind", ")", ";", "expr", "=", "fold_build1", "(", "code", ",", "dest_type", ",", "expr", ")", ";", "}", "gimplify_assign", "(", "dest_var", ",", "expr", ",", "seq", ")", ";", "}", "</s>" ]

[ "Emit", "a", "SHFL.DOWN", "using", "index", "SHFL", "of", "VAR", "into", "DEST_VAR", ".", "This", "function", "will", "cast", "the", "variable", "if", "necessary", "." ]

[ "nvptx", "3", "3", "3" ]

[]

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

[ "Check", "whether", "this", "section", "is", "``", "virtual", "''", ",", "that", "is", "has", "no", "actual", "object", "file", "contents", "." ]

[ "NVPTX" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCRetInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCRetInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_PPC", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ";", "Chain", "=", "Val", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Val", ".", "getValue", "(", "2", ")", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "}", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "ISD::InputArg", "16", "PPC", "0", "\"Can only return in registers!\"", "1", "2", "\"Unknown loc info!\"", "ISD::TRUNCATE", "ISD::AssertZext", "ISD::TRUNCATE", "ISD::AssertSext", "ISD::TRUNCATE" ]

[]

[ "<s>", "const", "SISubtarget", "*", "SITargetLowering", "::", "getSubtarget", "(", ")", "const", "{", "return", "Subtarget", ";", "}", "</s>" ]

[ "getSubtarget", "-", "Return", "the", "subtarget", "for", "which", "this", "machine", "code", "is", "being", "compiled", "." ]

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

[]

[ "<s>", "bool", "NVPTXAssignValidGlobalNames", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "for", "(", "GlobalVariable", "&", "GV", ":", "M", ".", "globals", "(", ")", ")", "{", "if", "(", "GV", ".", "hasLocalLinkage", "(", ")", ")", "{", "GV", ".", "setName", "(", "cleanUpName", "(", "GV", ".", "getName", "(", ")", ")", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX" ]

[]