Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "StringRef", "str", "(", ")", "{", "return", "OS", ".", "str", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "twine", "contents", "as", "a", "std", ":", ":string", "." ]

[ "HSAIL" ]

[]

[ "<s>", "void", "emitInst", "(", "uint32_t", "Inst", ",", "char", "Suffix", ")", "{", "unsigned", "Size", ";", "char", "Buffer", "[", "4", "]", ";", "const", "bool", "LittleEndian", "=", "getContext", "(", ")", ".", "getAsmInfo", "(", ")", "->", "isLittleEndian", "(", ")", ";", "switch", "(", "Suffix", ")", "{", "case", "'\\0'", ":", "Size", "=", "4", ";", "assert", "(", "!", "IsThumb", ")", ";", "EmitARMMappingSymbol", "(", ")", ";", "for", "(", "unsigned", "II", "=", "0", ",", "IE", "=", "Size", ";", "II", "!=", "IE", ";", "II", "++", ")", "{", "const", "unsigned", "I", "=", "LittleEndian", "?", "(", "Size", "-", "II", "-", "1", ")", ":", "II", ";", "Buffer", "[", "Size", "-", "II", "-", "1", "]", "=", "uint8_t", "(", "Inst", ">>", "I", "*", "CHAR_BIT", ")", ";", "}", "break", ";", "case", "'n'", ":", "case", "'w'", ":", "Size", "=", "(", "Suffix", "==", "'n'", "?", "2", ":", "4", ")", ";", "assert", "(", "IsThumb", ")", ";", "EmitThumbMappingSymbol", "(", ")", ";", "for", "(", "unsigned", "II", "=", "0", ",", "IE", "=", "Size", ";", "II", "!=", "IE", ";", "II", "=", "II", "+", "2", ")", "{", "const", "unsigned", "I0", "=", "LittleEndian", "?", "II", "+", "0", ":", "II", "+", "1", ";", "const", "unsigned", "I1", "=", "LittleEndian", "?", "II", "+", "1", ":", "II", "+", "0", ";", "Buffer", "[", "Size", "-", "II", "-", "2", "]", "=", "uint8_t", "(", "Inst", ">>", "I0", "*", "CHAR_BIT", ")", ";", "Buffer", "[", "Size", "-", "II", "-", "1", "]", "=", "uint8_t", "(", "Inst", ">>", "I1", "*", "CHAR_BIT", ")", ";", "}", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Invalid Suffix\"", ")", ";", "}", "MCELFStreamer", "::", "EmitBytes", "(", "StringRef", "(", "Buffer", ",", "Size", ")", ")", ";", "}", "</s>" ]

[ "Callback", "used", "to", "implement", "the", ".inst", "directive", "." ]

[ "ARM", "4", "4", "ARM", "0", "1", "1", "2", "4", "0", "2", "0", "1", "1", "0", "2", "1", "\"Invalid Suffix\"" ]

[]

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

[ "Enable", "the", "MachineScheduler", "pass", "for", "all", "X86", "subtargets", "." ]

[ "TPC" ]

[]

[ "<s>", "SDValue", "TeakTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "isVarArg", ")", "{", "report_fatal_error", "(", "\"VarArg not supported\"", ")", ";", "}", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Teak", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "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", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "{", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "TeakISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "Teak", "Teak", "ISD::OutputArg", "\"VarArg not supported\"", "16", "Teak", "4", "1", "0", "\"Can only return in registers!\"", "1", "0", "TeakISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "void", "AMDGPUInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "llvm_unreachable", "(", "\"Not Implemented\"", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "R600", "\"Not Implemented\"" ]

[]

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

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

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

[]

[ "<s>", "static", "const", "TargetRegisterClass", "*", "getRegClass", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "Reg", ")", "{", "if", "(", "MI", ".", "getParent", "(", ")", "==", "nullptr", ")", "return", "nullptr", ";", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "return", "MF", "?", "MF", "->", "getRegInfo", "(", ")", ".", "getRegClassOrNull", "(", "Reg", ")", ":", "nullptr", ";", "}", "</s>" ]

[ "Given", "a", "machine", "instruction", "descriptor", ",", "returns", "the", "register", "class", "constraint", "for", "OpNum", ",", "or", "NULL", "." ]

[ "AArch64" ]

[]

[ "<s>", "unsigned", "AVRInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "{", "const", "MCInstrDesc", "&", "Desc", "=", "get", "(", "Opcode", ")", ";", "return", "Desc", ".", "getSize", "(", ")", ";", "}", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "0", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "{", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "AVRTargetMachine", "&", "TM", "=", "static_cast", "<", "const", "AVRTargetMachine", "&", ">", "(", "MF", "->", "getTarget", "(", ")", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "return", "TII", ".", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "TM", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "SystemZPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createSystemZISelDag", "(", "getSystemZTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createSystemZLDCleanupPass", "(", "getSystemZTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "WebAssemblyFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "uint64_t", "StackSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "if", "(", "!", "needsSP", "(", "MF", ")", "||", "!", "needsSPWriteback", "(", "MF", ")", ")", "return", ";", "auto", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ";", "const", "auto", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "InsertPt", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "InsertPt", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "InsertPt", "->", "getDebugLoc", "(", ")", ";", "unsigned", "SPReg", "=", "0", ";", "unsigned", "SPFPReg", "=", "hasFP", "(", "MF", ")", "?", "getFPReg", "(", "MF", ")", ":", "getSPReg", "(", "MF", ")", ";", "if", "(", "hasBP", "(", "MF", ")", ")", "{", "auto", "FI", "=", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "SPReg", "=", "FI", "->", "getBasePointerVreg", "(", ")", ";", "}", "else", "if", "(", "StackSize", ")", "{", "const", "TargetRegisterClass", "*", "PtrRC", "=", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getPointerRegClass", "(", "MF", ")", ";", "Register", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "getOpcConst", "(", "MF", ")", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "StackSize", ")", ";", "SPReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "getOpcAdd", "(", "MF", ")", ")", ",", "SPReg", ")", ".", "addReg", "(", "SPFPReg", ")", ".", "addReg", "(", "OffsetReg", ")", ";", "}", "else", "{", "SPReg", "=", "SPFPReg", ";", "}", "writeSPToGlobal", "(", "SPReg", ",", "MF", ",", "MBB", ",", "InsertPt", ",", "DL", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "AMDGPUTargetLowering", "::", "ComputeNumSignBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPUISD", "::", "BFE_I32", ":", "{", "ConstantSDNode", "*", "Width", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "if", "(", "!", "Width", ")", "return", "1", ";", "unsigned", "SignBits", "=", "32", "-", "Width", "->", "getZExtValue", "(", ")", "+", "1", ";", "if", "(", "!", "isNullConstant", "(", "Op", ".", "getOperand", "(", "1", ")", ")", ")", "return", "SignBits", ";", "unsigned", "Op0SignBits", "=", "DAG", ".", "ComputeNumSignBits", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "Depth", "+", "1", ")", ";", "return", "std", "::", "max", "(", "SignBits", ",", "Op0SignBits", ")", ";", "}", "case", "AMDGPUISD", "::", "BFE_U32", ":", "{", "ConstantSDNode", "*", "Width", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "return", "Width", "?", "32", "-", "(", "Width", "->", "getZExtValue", "(", ")", "&", "0x1f", ")", ":", "1", ";", "}", "case", "AMDGPUISD", "::", "CARRY", ":", "case", "AMDGPUISD", "::", "BORROW", ":", "return", "31", ";", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

[ "Determine", "the", "number", "of", "bits", "in", "the", "operation", "that", "are", "sign", "bits", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPUISD::BFE_I32", "2", "1", "32", "1", "1", "0", "1", "AMDGPUISD::BFE_U32", "2", "32", "0x1f", "1", "AMDGPUISD::CARRY", "AMDGPUISD::BORROW", "31", "1" ]

[]

[ "<s>", "void", "CJGInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "CJG", "::", "PUSH", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "</s>" ]

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

[ "CJG", "CJG", "CJG::PUSH" ]

[]

[ "<s>", "void", "ix86_function_specific_restore", "(", "struct", "gcc_options", "*", "opts", ",", "struct", "gcc_options", "*", ",", "struct", "cl_target_option", "*", "ptr", ")", "{", "enum", "processor_type", "old_tune", "=", "ix86_tune", ";", "enum", "processor_type", "old_arch", "=", "ix86_arch", ";", "unsigned", "HOST_WIDE_INT", "ix86_arch_mask", ";", "int", "i", ";", "opts", "->", "x_flag_pic", "=", "flag_pic", ";", "ix86_arch", "=", "(", "enum", "processor_type", ")", "ptr", "->", "arch", ";", "ix86_schedule", "=", "(", "enum", "attr_cpu", ")", "ptr", "->", "schedule", ";", "ix86_tune", "=", "(", "enum", "processor_type", ")", "ptr", "->", "tune", ";", "ix86_prefetch_sse", "=", "ptr", "->", "prefetch_sse", ";", "ix86_tune_defaulted", "=", "ptr", "->", "tune_defaulted", ";", "ix86_arch_specified", "=", "ptr", "->", "arch_specified", ";", "opts", "->", "x_ix86_isa_flags_explicit", "=", "ptr", "->", "x_ix86_isa_flags_explicit", ";", "opts", "->", "x_ix86_isa_flags2_explicit", "=", "ptr", "->", "x_ix86_isa_flags2_explicit", ";", "opts", "->", "x_recip_mask_explicit", "=", "ptr", "->", "x_recip_mask_explicit", ";", "opts", "->", "x_ix86_arch_string", "=", "ptr", "->", "x_ix86_arch_string", ";", "opts", "->", "x_ix86_tune_string", "=", "ptr", "->", "x_ix86_tune_string", ";", "opts", "->", "x_ix86_asm_dialect", "=", "ptr", "->", "x_ix86_asm_dialect", ";", "opts", "->", "x_ix86_branch_cost", "=", "ptr", "->", "x_ix86_branch_cost", ";", "opts", "->", "x_ix86_dump_tunes", "=", "ptr", "->", "x_ix86_dump_tunes", ";", "opts", "->", "x_ix86_force_align_arg_pointer", "=", "ptr", "->", "x_ix86_force_align_arg_pointer", ";", "opts", "->", "x_ix86_force_drap", "=", "ptr", "->", "x_ix86_force_drap", ";", "opts", "->", "x_ix86_recip_name", "=", "ptr", "->", "x_ix86_recip_name", ";", "opts", "->", "x_ix86_section_threshold", "=", "ptr", "->", "x_ix86_section_threshold", ";", "opts", "->", "x_ix86_sse2avx", "=", "ptr", "->", "x_ix86_sse2avx", ";", "opts", "->", "x_ix86_stack_protector_guard", "=", "ptr", "->", "x_ix86_stack_protector_guard", ";", "opts", "->", "x_ix86_stringop_alg", "=", "ptr", "->", "x_ix86_stringop_alg", ";", "opts", "->", "x_ix86_tls_dialect", "=", "ptr", "->", "x_ix86_tls_dialect", ";", "opts", "->", "x_ix86_tune_ctrl_string", "=", "ptr", "->", "x_ix86_tune_ctrl_string", ";", "opts", "->", "x_ix86_tune_memcpy_strategy", "=", "ptr", "->", "x_ix86_tune_memcpy_strategy", ";", "opts", "->", "x_ix86_tune_memset_strategy", "=", "ptr", "->", "x_ix86_tune_memset_strategy", ";", "opts", "->", "x_ix86_tune_no_default", "=", "ptr", "->", "x_ix86_tune_no_default", ";", "ix86_tune_cost", "=", "processor_cost_table", "[", "ix86_tune", "]", ";", "if", "(", "opts", "->", "x_optimize_size", ")", "ix86_cost", "=", "&", "ix86_size_cost", ";", "else", "ix86_cost", "=", "ix86_tune_cost", ";", "if", "(", "old_arch", "!=", "ix86_arch", ")", "{", "ix86_arch_mask", "=", "HOST_WIDE_INT_1U", "<<", "ix86_arch", ";", "for", "(", "i", "=", "0", ";", "i", "<", "X86_ARCH_LAST", ";", "++", "i", ")", "ix86_arch_features", "[", "i", "]", "=", "!", "!", "(", "initial_ix86_arch_features", "[", "i", "]", "&", "ix86_arch_mask", ")", ";", "}", "if", "(", "old_tune", "!=", "ix86_tune", ")", "set_ix86_tune_features", "(", "opts", ",", "ix86_tune", ",", "false", ")", ";", "}", "</s>" ]

[ "Restore", "the", "current", "options" ]

[ "i386", "0" ]

[]

[ "<s>", "static", "bool", "s390_match_ccmode_set", "(", "rtx", "set", ",", "machine_mode", "req_mode", ")", "{", "machine_mode", "set_mode", ";", "gcc_assert", "(", "GET_CODE", "(", "set", ")", "==", "SET", ")", ";", "gcc_assert", "(", "req_mode", "!=", "CCVIALLmode", "&&", "req_mode", "!=", "CCVIANYmode", "&&", "req_mode", "!=", "CCVFALLmode", "&&", "req_mode", "!=", "CCVFANYmode", ")", ";", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "set", ")", ")", "!=", "REG", "||", "!", "CC_REGNO_P", "(", "REGNO", "(", "SET_DEST", "(", "set", ")", ")", ")", ")", "return", "1", ";", "set_mode", "=", "GET_MODE", "(", "SET_DEST", "(", "set", ")", ")", ";", "switch", "(", "set_mode", ")", "{", "case", "CCZ1mode", ":", "case", "CCSmode", ":", "case", "CCSRmode", ":", "case", "CCUmode", ":", "case", "CCURmode", ":", "case", "CCLmode", ":", "case", "CCL1mode", ":", "case", "CCL2mode", ":", "case", "CCL3mode", ":", "case", "CCT1mode", ":", "case", "CCT2mode", ":", "case", "CCT3mode", ":", "case", "CCVEQmode", ":", "case", "CCVIHmode", ":", "case", "CCVIHUmode", ":", "case", "CCVFHmode", ":", "case", "CCVFHEmode", ":", "if", "(", "req_mode", "!=", "set_mode", ")", "return", "0", ";", "break", ";", "case", "CCZmode", ":", "if", "(", "req_mode", "!=", "CCSmode", "&&", "req_mode", "!=", "CCUmode", "&&", "req_mode", "!=", "CCTmode", "&&", "req_mode", "!=", "CCSRmode", "&&", "req_mode", "!=", "CCURmode", "&&", "req_mode", "!=", "CCZ1mode", ")", "return", "0", ";", "break", ";", "case", "CCAPmode", ":", "case", "CCANmode", ":", "if", "(", "req_mode", "!=", "CCAmode", ")", "return", "0", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "(", "GET_MODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "set_mode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "SET", "either", "does", "n't", "set", "the", "CC", "register", ",", "or", "else", "the", "source", "and", "destination", "have", "matching", "CC", "modes", "and", "that", "CC", "mode", "is", "at", "least", "as", "constrained", "as", "REQ_MODE", "." ]

[ "s390", "1", "0", "0", "0" ]

[]

[ "<s>", "static", "uint32_t", "getBranchTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpIdx", ",", "unsigned", "FixupKind", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpIdx", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"Unexpected branch target type!\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "MCFixupKind", "Kind", "=", "MCFixupKind", "(", "FixupKind", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "Expr", ",", "Kind", ",", "MI", ".", "getLoc", "(", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getBranchTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

[ "ARM", "\"Unexpected branch target type!\"", "0", "0" ]

[]

[ "<s>", "size_t", "size", "(", ")", "{", "return", "Q", ".", "size", "(", ")", "+", "HaveConst", ";", "}", "</s>" ]

[ "The", "number", "of", "name/type", "pairs", "is", "returned", "." ]

[ "Hexagon" ]

[]

[ "<s>", "rtx", "legitimize_pic_address", "(", "rtx", "orig", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "reg", ")", "{", "rtx", "pic_ref", "=", "orig", ";", "if", "(", "GET_CODE", "(", "orig", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "orig", ")", "==", "LABEL_REF", ")", "{", "gcc_assert", "(", "reg", ")", ";", "pic_ref", "=", "m68k_wrap_symbol_into_got_ref", "(", "orig", ",", "RELOC_GOT", ",", "reg", ")", ";", "pic_ref", "=", "m68k_move_to_reg", "(", "pic_ref", ",", "orig", ",", "reg", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "orig", ")", "==", "CONST", ")", "{", "rtx", "base", ";", "if", "(", "m68k_unwrap_symbol", "(", "orig", ",", "true", ")", "!=", "orig", ")", "return", "orig", ";", "gcc_assert", "(", "reg", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "orig", ",", "0", ")", ")", "==", "PLUS", ")", ";", "base", "=", "legitimize_pic_address", "(", "XEXP", "(", "XEXP", "(", "orig", ",", "0", ")", ",", "0", ")", ",", "Pmode", ",", "reg", ")", ";", "orig", "=", "legitimize_pic_address", "(", "XEXP", "(", "XEXP", "(", "orig", ",", "0", ")", ",", "1", ")", ",", "Pmode", ",", "base", "==", "reg", "?", "0", ":", "reg", ")", ";", "if", "(", "GET_CODE", "(", "orig", ")", "==", "CONST_INT", ")", "pic_ref", "=", "plus_constant", "(", "Pmode", ",", "base", ",", "INTVAL", "(", "orig", ")", ")", ";", "else", "pic_ref", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "base", ",", "orig", ")", ";", "}", "return", "pic_ref", ";", "}", "</s>" ]

[ "Legitimize", "PIC", "addresses", ".", "If", "the", "address", "is", "already", "position-independent", ",", "we", "return", "ORIG", ".", "Newly", "generated", "position-independent", "addresses", "go", "into", "a", "reg", ".", "This", "is", "REG", "if", "nonzero", ",", "otherwise", "we", "allocate", "register", "(", "s", ")", "as", "necessary", "." ]

[ "m68k", "0", "0", "0", "0", "1", "0" ]

[]

[ "<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", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_XCore", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "0", ",", "MVT", "::", "i32", ")", ")", ";", "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", ")", ";", "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", "[", "0", "]", ",", "RetOps", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "ISD::OutputArg", "16", "XCore", "4", "1", "0", "MVT::i32", "0", "\"Can only return in registers!\"", "1", "0", "XCoreISD::RETSP", "MVT::Other", "0" ]

[]

[ "<s>", "static", "void", "rs6000_setup_reg_addr_masks", "(", "void", ")", "{", "ssize_t", "rc", ",", "reg", ",", "m", ",", "nregs", ";", "addr_mask_type", "any_addr_mask", ",", "addr_mask", ";", "for", "(", "m", "=", "0", ";", "m", "<", "NUM_MACHINE_MODES", ";", "++", "m", ")", "{", "machine_mode", "m2", "=", "(", "machine_mode", ")", "m", ";", "bool", "complex_p", "=", "false", ";", "bool", "small_int_p", "=", "(", "m2", "==", "QImode", "||", "m2", "==", "HImode", "||", "m2", "==", "SImode", ")", ";", "size_t", "msize", ";", "if", "(", "COMPLEX_MODE_P", "(", "m2", ")", ")", "{", "complex_p", "=", "true", ";", "m2", "=", "GET_MODE_INNER", "(", "m2", ")", ";", "}", "msize", "=", "GET_MODE_SIZE", "(", "m2", ")", ";", "bool", "indexed_only_p", "=", "(", "m", "==", "SDmode", "&&", "TARGET_NO_SDMODE_STACK", ")", ";", "any_addr_mask", "=", "0", ";", "for", "(", "rc", "=", "FIRST_RELOAD_REG_CLASS", ";", "rc", "<=", "LAST_RELOAD_REG_CLASS", ";", "rc", "++", ")", "{", "addr_mask", "=", "0", ";", "reg", "=", "reload_reg_map", "[", "rc", "]", ".", "reg", ";", "if", "(", "reg", ">=", "0", "&&", "rs6000_hard_regno_mode_ok_p", "[", "m", "]", "[", "reg", "]", ")", "{", "bool", "small_int_vsx_p", "=", "(", "small_int_p", "&&", "(", "rc", "==", "RELOAD_REG_FPR", "||", "rc", "==", "RELOAD_REG_VMX", ")", ")", ";", "nregs", "=", "rs6000_hard_regno_nregs", "[", "m", "]", "[", "reg", "]", ";", "addr_mask", "|=", "RELOAD_REG_VALID", ";", "if", "(", "small_int_vsx_p", ")", "addr_mask", "|=", "RELOAD_REG_INDEXED", ";", "else", "if", "(", "nregs", ">", "1", "||", "m", "==", "BLKmode", "||", "complex_p", ")", "addr_mask", "|=", "RELOAD_REG_MULTIPLE", ";", "else", "addr_mask", "|=", "RELOAD_REG_INDEXED", ";", "if", "(", "TARGET_UPDATE", "&&", "(", "rc", "==", "RELOAD_REG_GPR", "||", "rc", "==", "RELOAD_REG_FPR", ")", "&&", "msize", "<=", "8", "&&", "!", "VECTOR_MODE_P", "(", "m2", ")", "&&", "!", "FLOAT128_VECTOR_P", "(", "m2", ")", "&&", "!", "complex_p", "&&", "!", "small_int_vsx_p", "&&", "(", "m2", "!=", "DFmode", "||", "!", "TARGET_UPPER_REGS_DF", ")", "&&", "(", "m2", "!=", "SFmode", "||", "!", "TARGET_UPPER_REGS_SF", ")", "&&", "!", "(", "TARGET_E500_DOUBLE", "&&", "msize", "==", "8", ")", ")", "{", "addr_mask", "|=", "RELOAD_REG_PRE_INCDEC", ";", "switch", "(", "m", ")", "{", "default", ":", "addr_mask", "|=", "RELOAD_REG_PRE_MODIFY", ";", "break", ";", "case", "E_DImode", ":", "if", "(", "TARGET_POWERPC64", ")", "addr_mask", "|=", "RELOAD_REG_PRE_MODIFY", ";", "break", ";", "case", "E_DFmode", ":", "case", "E_DDmode", ":", "if", "(", "TARGET_DF_INSN", ")", "addr_mask", "|=", "RELOAD_REG_PRE_MODIFY", ";", "break", ";", "}", "}", "}", "if", "(", "(", "addr_mask", "!=", "0", ")", "&&", "!", "indexed_only_p", "&&", "msize", "<=", "8", "&&", "(", "rc", "==", "RELOAD_REG_GPR", "||", "(", "(", "msize", "==", "8", "||", "m2", "==", "SFmode", ")", "&&", "(", "rc", "==", "RELOAD_REG_FPR", "||", "(", "rc", "==", "RELOAD_REG_VMX", "&&", "TARGET_P9_DFORM_SCALAR", ")", ")", ")", ")", ")", "addr_mask", "|=", "RELOAD_REG_OFFSET", ";", "else", "if", "(", "(", "addr_mask", "!=", "0", ")", "&&", "!", "indexed_only_p", "&&", "msize", "==", "16", "&&", "TARGET_P9_DFORM_VECTOR", "&&", "(", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "m2", ")", "||", "(", "m2", "==", "TImode", "&&", "TARGET_VSX_TIMODE", ")", ")", ")", "{", "addr_mask", "|=", "RELOAD_REG_OFFSET", ";", "if", "(", "rc", "==", "RELOAD_REG_FPR", "||", "rc", "==", "RELOAD_REG_VMX", ")", "addr_mask", "|=", "RELOAD_REG_QUAD_OFFSET", ";", "}", "if", "(", "rc", "==", "RELOAD_REG_VMX", "&&", "msize", "==", "16", "&&", "(", "addr_mask", "&", "RELOAD_REG_VALID", ")", "!=", "0", ")", "addr_mask", "|=", "RELOAD_REG_AND_M16", ";", "reg_addr", "[", "m", "]", ".", "addr_mask", "[", "rc", "]", "=", "addr_mask", ";", "any_addr_mask", "|=", "addr_mask", ";", "}", "reg_addr", "[", "m", "]", ".", "addr_mask", "[", "RELOAD_REG_ANY", "]", "=", "any_addr_mask", ";", "}", "}", "</s>" ]

[ "Update", "the", "addr", "mask", "bits", "in", "reg_addr", "to", "help", "secondary", "reload", "and", "go", "if", "legitimate", "address", "support", "to", "figure", "out", "the", "appropriate", "addressing", "to", "use", "." ]

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

[]

[ "<s>", "void", "rx_split_cbranch", "(", "machine_mode", "cc_mode", ",", "enum", "rtx_code", "cmp1", ",", "rtx", "c1", ",", "rtx", "c2", ",", "rtx", "label", ")", "{", "rtx", "flags", ",", "x", ";", "flags", "=", "gen_rtx_REG", "(", "cc_mode", ",", "CC_REG", ")", ";", "x", "=", "gen_rtx_COMPARE", "(", "cc_mode", ",", "c1", ",", "c2", ")", ";", "x", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "flags", ",", "x", ")", ";", "emit_insn", "(", "x", ")", ";", "x", "=", "gen_rtx_fmt_ee", "(", "cmp1", ",", "VOIDmode", ",", "flags", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "label", ",", "pc_rtx", ")", ";", "x", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "x", ")", ";", "emit_jump_insn", "(", "x", ")", ";", "}", "</s>" ]

[ "Split", "the", "conditional", "branch", ".", "Emit", "(", "COMPARE", "C1", "C2", ")", "into", "CC_REG", "with", "CC_MODE", ",", "and", "use", "that", "in", "branches", "based", "on", "that", "compare", "." ]

[ "rx" ]

[]

[ "<s>", "bool", "PPCPassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "!", "DisableInstrFormPrep", "&&", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createPPCLoopInstrFormPrepPass", "(", "getPPCTargetMachine", "(", ")", ")", ")", ";", "if", "(", "!", "DisableCTRLoops", "&&", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createHardwareLoopsPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "bool", "arc_need_delay", "(", "rtx_insn", "*", "insn", ")", "{", "rtx_insn", "*", "next", ";", "if", "(", "!", "flag_delayed_branch", ")", "return", "false", ";", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "&&", "(", "!", "(", "next", "=", "next_active_insn", "(", "insn", ")", ")", "||", "(", "(", "!", "NONJUMP_INSN_P", "(", "next", ")", "||", "GET_CODE", "(", "PATTERN", "(", "next", ")", ")", "!=", "SEQUENCE", ")", "&&", "arc_attr_type", "(", "next", ")", "==", "TYPE_RETURN", ")", ")", "&&", "(", "!", "TARGET_PAD_RETURN", "||", "(", "prev_active_insn", "(", "insn", ")", "&&", "prev_active_insn", "(", "prev_active_insn", "(", "insn", ")", ")", "&&", "prev_active_insn", "(", "prev_active_insn", "(", "prev_active_insn", "(", "insn", ")", ")", ")", ")", ")", ")", "return", "true", ";", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", "?", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SEQUENCE", ")", ":", "JUMP_P", "(", "insn", ")", "?", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ADDR_VEC", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ADDR_DIFF_VEC", ")", ":", "!", "CALL_P", "(", "insn", ")", ")", "return", "false", ";", "return", "num_delay_slots", "(", "insn", ")", "!=", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "INSN", "is", "an", "instruction", "with", "a", "delay", "slot", "we", "may", "want", "to", "fill", "." ]

[ "arc", "0" ]

[]

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

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

[ "AMDGPU", "\"SI Lower i1 Copies\"" ]

[]

[ "<s>", "bool", "WebAssemblyAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "return", "AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "OS", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "bool", "aarch64_gimple_fold_builtin", "(", "gimple_stmt_iterator", "*", "gsi", ")", "{", "bool", "changed", "=", "false", ";", "gimple", "stmt", "=", "gsi_stmt", "(", "*", "gsi", ")", ";", "tree", "call", "=", "gimple_call_fn", "(", "stmt", ")", ";", "tree", "fndecl", ";", "gimple", "new_stmt", "=", "NULL", ";", "if", "(", "call", ")", "{", "fndecl", "=", "gimple_call_fndecl", "(", "stmt", ")", ";", "if", "(", "fndecl", ")", "{", "int", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "int", "nargs", "=", "gimple_call_num_args", "(", "stmt", ")", ";", "tree", "*", "args", "=", "(", "nargs", ">", "0", "?", "gimple_call_arg_ptr", "(", "stmt", ",", "0", ")", ":", "&", "error_mark_node", ")", ";", "switch", "(", "fcode", ")", "{", "BUILTIN_VALL", "(", "UNOP", ",", "reduc_plus_scal_", ",", "10", ")", "new_stmt", "=", "gimple_build_assign", "(", "gimple_call_lhs", "(", "stmt", ")", ",", "REDUC_PLUS_EXPR", ",", "args", "[", "0", "]", ")", ";", "break", ";", "BUILTIN_VDQIF", "(", "UNOP", ",", "reduc_smax_scal_", ",", "10", ")", "BUILTIN_VDQ_BHSI", "(", "UNOPU", ",", "reduc_umax_scal_", ",", "10", ")", "new_stmt", "=", "gimple_build_assign", "(", "gimple_call_lhs", "(", "stmt", ")", ",", "REDUC_MAX_EXPR", ",", "args", "[", "0", "]", ")", ";", "break", ";", "BUILTIN_VDQIF", "(", "UNOP", ",", "reduc_smin_scal_", ",", "10", ")", "BUILTIN_VDQ_BHSI", "(", "UNOPU", ",", "reduc_umin_scal_", ",", "10", ")", "new_stmt", "=", "gimple_build_assign", "(", "gimple_call_lhs", "(", "stmt", ")", ",", "REDUC_MIN_EXPR", ",", "args", "[", "0", "]", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "}", "if", "(", "new_stmt", ")", "{", "gsi_replace", "(", "gsi", ",", "new_stmt", ",", "true", ")", ";", "changed", "=", "true", ";", "}", "return", "changed", ";", "}", "</s>" ]

[ "Implement", "TARGET_GIMPLE_FOLD_BUILTIN", "." ]

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

[]

[ "<s>", "bool", "MSP430PassConfig", "::", "addPreEmitPass", "(", ")", "{", "PM", ".", "add", "(", "createMSP430BranchSelectionPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "{", "return", "get", "(", "Opcode", ")", ".", "getSize", "(", ")", ";", "}", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "0", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "auto", "&", "TM", "=", "static_cast", "<", "const", "RISCVTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "TM", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "s390_function_arg_vector", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "!", "TARGET_VX_ABI", ")", "return", "false", ";", "if", "(", "s390_function_arg_size", "(", "mode", ",", "type", ")", ">", "16", ")", "return", "false", ";", "if", "(", "!", "type", ")", "return", "VECTOR_MODE_P", "(", "mode", ")", ";", "if", "(", "!", "s390_single_field_struct_p", "(", "VECTOR_TYPE", ",", "type", ",", "true", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "function", "argument", "of", "type", "TYPE", "and", "mode", "MODE", "is", "to", "be", "passed", "in", "a", "vector", "register", ",", "if", "available", "." ]

[ "s390", "16" ]

[]

[ "<s>", "const", "MCExpr", "*", "getSubExpr", "(", ")", "const", "{", "return", "Expr", ";", "}", "</s>" ]

[ "getSubExpr", "-", "Get", "the", "child", "of", "this", "expression", "." ]

[ "RI5CY" ]

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "FISC" ]

[]

[ "<s>", "unsigned", "char", "M680x0Subtarget", "::", "classifyBlockAddressReference", "(", ")", "const", "{", "return", "M680x0II", "::", "MO_PC_RELATIVE_ADDRESS", ";", "}", "</s>" ]

[ "Classify", "a", "blockaddress", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "." ]

[ "M680x0", "M680x0", "M680x0II::MO_PC_RELATIVE_ADDRESS" ]

[]

[ "<s>", "const", "char", "*", "MipsAsmPrinter", "::", "getCurrentABIString", "(", ")", "const", "{", "switch", "(", "Subtarget", "->", "getTargetABI", "(", ")", ")", "{", "case", "MipsSubtarget", "::", "O32", ":", "return", "\"abi32\"", ";", "case", "MipsSubtarget", "::", "O64", ":", "return", "\"abiO64\"", ";", "case", "MipsSubtarget", "::", "N32", ":", "return", "\"abiN32\"", ";", "case", "MipsSubtarget", "::", "N64", ":", "return", "\"abi64\"", ";", "case", "MipsSubtarget", "::", "EABI", ":", "return", "\"eabi32\"", ";", "default", ":", "break", ";", "}", "llvm_unreachable", "(", "\"Unknown Mips ABI\"", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Emit", "Set", "directives", "." ]

[ "Mips", "Mips", "Mips", "\"abi32\"", "Mips", "\"abiO64\"", "Mips", "\"abiN32\"", "Mips", "\"abi64\"", "Mips", "\"eabi32\"", "\"Unknown Mips ABI\"" ]

[]

[ "<s>", "static", "void", "output_init_frag", "(", "rtx", "sym", ")", "{", "fprintf", "(", "asm_out_file", ",", "init_frag", ".", "started", "?", "\", \"", ":", "\" = { \"", ")", ";", "unsigned", "HOST_WIDE_INT", "val", "=", "init_frag", ".", "val", ";", "init_frag", ".", "started", "=", "true", ";", "init_frag", ".", "val", "=", "0", ";", "init_frag", ".", "offset", "=", "0", ";", "init_frag", ".", "remaining", "--", ";", "if", "(", "sym", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"generic(\"", ")", ";", "output_address", "(", "VOIDmode", ",", "sym", ")", ";", "fprintf", "(", "asm_out_file", ",", "val", "?", "\") + \"", ":", "\")\"", ")", ";", "}", "if", "(", "!", "sym", "||", "val", ")", "fprintf", "(", "asm_out_file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "val", ")", ";", "}", "</s>" ]

[ "The", "current", "fragment", "is", "full", ",", "write", "it", "out", ".", "SYM", "may", "provide", "a", "symbolic", "reference", "we", "should", "output", ",", "in", "which", "case", "the", "fragment", "value", "is", "the", "addend", "." ]

[ "nvptx", "\", \"", "\" = { \"", "0", "0", "\"generic(\"", "\") + \"", "\")\"" ]

[]

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

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "DebugLoc", "dl", "=", "N", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "STORE", ":", "{", "StoreSDNode", "*", "ST", "=", "cast", "<", "StoreSDNode", ">", "(", "N", ")", ";", "if", "(", "!", "DCI", ".", "isBeforeLegalize", "(", ")", "||", "allowsUnalignedMemoryAccesses", "(", "ST", "->", "getMemoryVT", "(", ")", ")", "||", "ST", "->", "isVolatile", "(", ")", "||", "ST", "->", "isIndexed", "(", ")", ")", "{", "break", ";", "}", "SDValue", "Chain", "=", "ST", "->", "getChain", "(", ")", ";", "unsigned", "StoreBits", "=", "ST", "->", "getMemoryVT", "(", ")", ".", "getStoreSizeInBits", "(", ")", ";", "if", "(", "StoreBits", "%", "8", ")", "{", "break", ";", "}", "unsigned", "ABIAlignment", "=", "getTargetData", "(", ")", "->", "getABITypeAlignment", "(", "ST", "->", "getMemoryVT", "(", ")", ".", "getTypeForEVT", "(", "*", "DCI", ".", "DAG", ".", "getContext", "(", ")", ")", ")", ";", "unsigned", "Alignment", "=", "ST", "->", "getAlignment", "(", ")", ";", "if", "(", "Alignment", ">=", "ABIAlignment", ")", "{", "break", ";", "}", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "ST", "->", "getValue", "(", ")", ")", ")", "{", "if", "(", "LD", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", "&&", "ST", "->", "getMemoryVT", "(", ")", "==", "LD", "->", "getMemoryVT", "(", ")", "&&", "LD", "->", "getAlignment", "(", ")", "==", "Alignment", "&&", "!", "LD", "->", "isVolatile", "(", ")", "&&", "!", "LD", "->", "isIndexed", "(", ")", "&&", "Chain", ".", "reachesChainWithoutSideEffects", "(", "SDValue", "(", "LD", ",", "1", ")", ")", ")", "{", "return", "DAG", ".", "getMemmove", "(", "Chain", ",", "dl", ",", "ST", "->", "getBasePtr", "(", ")", ",", "LD", "->", "getBasePtr", "(", ")", ",", "DAG", ".", "getConstant", "(", "StoreBits", "/", "8", ",", "MVT", "::", "i32", ")", ",", "Alignment", ",", "ST", "->", "getSrcValue", "(", ")", ",", "ST", "->", "getSrcValueOffset", "(", ")", ",", "LD", "->", "getSrcValue", "(", ")", ",", "LD", "->", "getSrcValueOffset", "(", ")", ")", ";", "}", "}", "break", ";", "}", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "ISD::STORE", "8", "1", "0", "1", "8", "MVT::i32" ]

[]

[ "<s>", "virtual", "unsigned", "getByValTypeAlignment", "(", "Type", "*", "Ty", ")", "const", "LLVM_OVERRIDE", "{", "return", "4", ";", "}", "</s>" ]

[ "Return", "the", "desired", "alignment", "for", "ByVal", "aggregate", "function", "arguments", "in", "the", "caller", "parameter", "area", "." ]

[ "Patmos", "4" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "TargetAlign", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ";", "unsigned", "maxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "RoundUpToAlignment", "(", "maxCallFrameSize", ",", "TargetAlign", ")", ";", "MFI", "->", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "RoundUpToAlignment", "(", "FrameSize", ",", "TargetAlign", ")", ";", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "void", "rs6000_darwin64_record_arg_flush", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "HOST_WIDE_INT", "bitpos", ",", "rtx", "rvec", "[", "]", ",", "int", "*", "k", ")", "{", "machine_mode", "mode", ";", "unsigned", "int", "regno", ";", "unsigned", "int", "startbit", ",", "endbit", ";", "int", "this_regno", ",", "intregs", ",", "intoffset", ";", "rtx", "reg", ";", "if", "(", "cum", "->", "intoffset", "==", "-", "1", ")", "return", ";", "intoffset", "=", "cum", "->", "intoffset", ";", "cum", "->", "intoffset", "=", "-", "1", ";", "if", "(", "intoffset", "%", "BITS_PER_WORD", "!=", "0", ")", "{", "unsigned", "int", "bits", "=", "BITS_PER_WORD", "-", "intoffset", "%", "BITS_PER_WORD", ";", "if", "(", "!", "int_mode_for_size", "(", "bits", ",", "0", ")", ".", "exists", "(", "&", "mode", ")", ")", "{", "intoffset", "=", "ROUND_DOWN", "(", "intoffset", ",", "BITS_PER_WORD", ")", ";", "mode", "=", "word_mode", ";", "}", "}", "else", "mode", "=", "word_mode", ";", "startbit", "=", "ROUND_DOWN", "(", "intoffset", ",", "BITS_PER_WORD", ")", ";", "endbit", "=", "ROUND_UP", "(", "bitpos", ",", "BITS_PER_WORD", ")", ";", "intregs", "=", "(", "endbit", "-", "startbit", ")", "/", "BITS_PER_WORD", ";", "this_regno", "=", "cum", "->", "words", "+", "intoffset", "/", "BITS_PER_WORD", ";", "if", "(", "intregs", ">", "0", "&&", "intregs", ">", "GP_ARG_NUM_REG", "-", "this_regno", ")", "cum", "->", "use_stack", "=", "1", ";", "intregs", "=", "MIN", "(", "intregs", ",", "GP_ARG_NUM_REG", "-", "this_regno", ")", ";", "if", "(", "intregs", "<=", "0", ")", "return", ";", "intoffset", "/=", "BITS_PER_UNIT", ";", "do", "{", "regno", "=", "GP_ARG_MIN_REG", "+", "this_regno", ";", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "rvec", "[", "(", "*", "k", ")", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "GEN_INT", "(", "intoffset", ")", ")", ";", "this_regno", "+=", "1", ";", "intoffset", "=", "(", "intoffset", "|", "(", "UNITS_PER_WORD", "-", "1", ")", ")", "+", "1", ";", "mode", "=", "word_mode", ";", "intregs", "-=", "1", ";", "}", "while", "(", "intregs", ">", "0", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "rs6000_darwin64_record_arg", ".", "Assign", "the", "bits", "of", "the", "structure", "between", "cum-", ">", "intoffset", "and", "bitpos", "to", "integer", "registers", "." ]

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

[]

[ "<s>", "void", "ARMTargetLowering", "::", "emitLeadingFence", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "AtomicOrdering", "Ord", ",", "bool", "IsStore", ",", "bool", "IsLoad", ")", "const", "{", "if", "(", "!", "getInsertFencesForAtomic", "(", ")", ")", "return", ";", "switch", "(", "Ord", ")", "{", "case", "NotAtomic", ":", "case", "Unordered", ":", "llvm_unreachable", "(", "\"Invalid fence: unordered/non-atomic\"", ")", ";", "case", "Monotonic", ":", "case", "Acquire", ":", "return", ";", "case", "SequentiallyConsistent", ":", "if", "(", "!", "IsStore", ")", "return", ";", "case", "Release", ":", "case", "AcquireRelease", ":", "if", "(", "Subtarget", "->", "isSwift", "(", ")", ")", "makeDMB", "(", "Builder", ",", "ARM_MB", "::", "ISHST", ")", ";", "else", "makeDMB", "(", "Builder", ",", "ARM_MB", "::", "ISH", ")", ";", "return", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "\"Invalid fence: unordered/non-atomic\"", "ARM_MB::ISHST", "ARM_MB::ISH" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isFPRCopy", "(", "const", "MachineInstr", "&", "MI", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "TargetOpcode", "::", "COPY", ":", "{", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "return", "(", "AArch64", "::", "FPR64RegClass", ".", "contains", "(", "DstReg", ")", "||", "AArch64", "::", "FPR128RegClass", ".", "contains", "(", "DstReg", ")", ")", ";", "}", "case", "AArch64", "::", "ORRv16i8", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", "{", "assert", "(", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "==", "3", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "&&", "\"invalid ORRv16i8 operands\"", ")", ";", "return", "true", ";", "}", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Does", "this", "instruction", "rename", "an", "FPR", "without", "modifying", "bits", "?" ]

[ "AArch64", "AArch64", "0", "AArch64::FPR64RegClass", "AArch64::FPR128RegClass", "AArch64::ORRv16i8", "1", "2", "3", "0", "\"invalid ORRv16i8 operands\"" ]

[]

[ "<s>", "bool", "arc_is_shortcall_p", "(", "rtx", "sym_ref", ")", "{", "if", "(", "GET_CODE", "(", "sym_ref", ")", "!=", "SYMBOL_REF", ")", "return", "false", ";", "return", "(", "SYMBOL_REF_SHORT_CALL_P", "(", "sym_ref", ")", "||", "(", "!", "TARGET_LONG_CALLS_SET", "&&", "!", "TARGET_MEDIUM_CALLS", "&&", "!", "SYMBOL_REF_LONG_CALL_P", "(", "sym_ref", ")", "&&", "!", "SYMBOL_REF_MEDIUM_CALL_P", "(", "sym_ref", ")", ")", ")", ";", "}", "</s>" ]

[ "Likewise", "for", "short", "calls", "." ]

[ "arc" ]

[]

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

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

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

[]

[ "<s>", "void", "WebAssemblyExceptionInfo", "::", "releaseMemory", "(", ")", "{", "BBMap", ".", "clear", "(", ")", ";", "DeleteContainerPointers", "(", "TopLevelExceptions", ")", ";", "TopLevelExceptions", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "releaseMemory", "(", ")", "-", "This", "member", "can", "be", "implemented", "by", "a", "pass", "if", "it", "wants", "to", "be", "able", "to", "release", "its", "memory", "when", "it", "is", "no", "longer", "needed", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "getPreIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "false", ";", "EVT", "VT", ";", "SDValue", "Ptr", ";", "unsigned", "Align", ";", "bool", "isSEXTLoad", "=", "false", ";", "bool", "IsMasked", "=", "false", ";", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "Ptr", "=", "LD", "->", "getBasePtr", "(", ")", ";", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "Align", "=", "LD", "->", "getAlignment", "(", ")", ";", "isSEXTLoad", "=", "LD", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "SEXTLOAD", ";", "}", "else", "if", "(", "StoreSDNode", "*", "ST", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ")", "{", "Ptr", "=", "ST", "->", "getBasePtr", "(", ")", ";", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "Align", "=", "ST", "->", "getAlignment", "(", ")", ";", "}", "else", "if", "(", "MaskedLoadSDNode", "*", "LD", "=", "dyn_cast", "<", "MaskedLoadSDNode", ">", "(", "N", ")", ")", "{", "Ptr", "=", "LD", "->", "getBasePtr", "(", ")", ";", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "Align", "=", "LD", "->", "getAlignment", "(", ")", ";", "isSEXTLoad", "=", "LD", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "SEXTLOAD", ";", "IsMasked", "=", "true", ";", "}", "else", "if", "(", "MaskedStoreSDNode", "*", "ST", "=", "dyn_cast", "<", "MaskedStoreSDNode", ">", "(", "N", ")", ")", "{", "Ptr", "=", "ST", "->", "getBasePtr", "(", ")", ";", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "Align", "=", "ST", "->", "getAlignment", "(", ")", ";", "IsMasked", "=", "true", ";", "}", "else", "return", "false", ";", "bool", "isInc", ";", "bool", "isLegal", "=", "false", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "isLegal", "=", "Subtarget", "->", "hasMVEIntegerOps", "(", ")", "&&", "getMVEIndexedAddressParts", "(", "Ptr", ".", "getNode", "(", ")", ",", "VT", ",", "Align", ",", "isSEXTLoad", ",", "IsMasked", ",", "Subtarget", "->", "isLittle", "(", ")", ",", "Base", ",", "Offset", ",", "isInc", ",", "DAG", ")", ";", "else", "{", "if", "(", "Subtarget", "->", "isThumb2", "(", ")", ")", "isLegal", "=", "getT2IndexedAddressParts", "(", "Ptr", ".", "getNode", "(", ")", ",", "VT", ",", "isSEXTLoad", ",", "Base", ",", "Offset", ",", "isInc", ",", "DAG", ")", ";", "else", "isLegal", "=", "getARMIndexedAddressParts", "(", "Ptr", ".", "getNode", "(", ")", ",", "VT", ",", "isSEXTLoad", ",", "Base", ",", "Offset", ",", "isInc", ",", "DAG", ")", ";", "}", "if", "(", "!", "isLegal", ")", "return", "false", ";", "AM", "=", "isInc", "?", "ISD", "::", "PRE_INC", ":", "ISD", "::", "PRE_DEC", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "the", "node", "'s", "address", "can", "be", "legally", "represented", "as", "pre-indexed", "load", "/", "store", "address", "." ]

[ "ARM", "ARM", "ISD::MemIndexedMode", "ISD::SEXTLOAD", "ISD::SEXTLOAD", "ARM", "ISD::PRE_INC", "ISD::PRE_DEC" ]

[]

[ "<s>", "bool", "isImm", "(", ")", "const", "override", "{", "return", "Kind", "==", "k_Immediate", ";", "}", "</s>" ]

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "OR1K" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "}", "</s>" ]

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

[ "SIC" ]

[]

[ "<s>", "static", "void", "mips_init_builtins", "(", "void", ")", "{", "const", "struct", "mips_builtin_description", "*", "d", ";", "unsigned", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "mips_builtins", ")", ";", "i", "++", ")", "{", "d", "=", "&", "mips_builtins", "[", "i", "]", ";", "if", "(", "d", "->", "avail", "(", ")", ")", "{", "mips_builtin_decls", "[", "i", "]", "=", "add_builtin_function", "(", "d", "->", "name", ",", "mips_build_function_type", "(", "d", "->", "function_type", ")", ",", "i", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL", ")", ";", "mips_get_builtin_decl_index", "[", "d", "->", "icode", "]", "=", "i", ";", "}", "}", "}", "</s>" ]

[ "Init", "builtin", "functions", ".", "This", "is", "called", "from", "TARGET_INIT_BUILTIN", "." ]

[ "mips", "0" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Imm", ".", "isPosZero", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "f64", "||", "VT", "==", "MVT", "::", "f32", "||", "(", "VT", "==", "MVT", "::", "f16", "&&", "Subtarget", "->", "hasFullFP16", "(", ")", ")", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Legal fp imm: materialize 0 using the zero register\\n\"", ")", ";", "return", "true", ";", "}", "StringRef", "FPType", ";", "bool", "IsLegal", "=", "false", ";", "SmallString", "<", "128", ">", "ImmStrVal", ";", "Imm", ".", "toString", "(", "ImmStrVal", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "{", "FPType", "=", "\"f64\"", ";", "IsLegal", "=", "AArch64_AM", "::", "getFP64Imm", "(", "Imm", ")", "!=", "-", "1", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "{", "FPType", "=", "\"f32\"", ";", "IsLegal", "=", "AArch64_AM", "::", "getFP32Imm", "(", "Imm", ")", "!=", "-", "1", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "f16", "&&", "Subtarget", "->", "hasFullFP16", "(", ")", ")", "{", "FPType", "=", "\"f16\"", ";", "IsLegal", "=", "AArch64_AM", "::", "getFP16Imm", "(", "Imm", ")", "!=", "-", "1", ";", "}", "if", "(", "IsLegal", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Legal \"", "<<", "FPType", "<<", "\" imm value: \"", "<<", "ImmStrVal", "<<", "\"\\n\"", ")", ";", "return", "true", ";", "}", "if", "(", "!", "FPType", ".", "empty", "(", ")", ")", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Illegal \"", "<<", "FPType", "<<", "\" imm value: \"", "<<", "ImmStrVal", "<<", "\"\\n\"", ")", ";", "else", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Illegal fp imm \"", "<<", "ImmStrVal", "<<", "\": unsupported fp type\\n\"", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "can", "instruction", "select", "the", "specified", "FP", "immediate", "natively", "." ]

[ "AArch64", "AArch64", "MVT::f64", "MVT::f32", "MVT::f16", "\"Legal fp imm: materialize 0 using the zero register\\n\"", "128", "MVT::f64", "\"f64\"", "AArch64_AM::getFP64Imm", "1", "MVT::f32", "\"f32\"", "AArch64_AM::getFP32Imm", "1", "MVT::f16", "\"f16\"", "AArch64_AM::getFP16Imm", "1", "\"Legal \"", "\" imm value: \"", "\"\\n\"", "\"Illegal \"", "\" imm value: \"", "\"\\n\"", "\"Illegal fp imm \"", "\": unsupported fp type\\n\"" ]

[]

[ "<s>", "bool", "MipsLongBranch", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "const", "MipsSubtarget", "&", "STI", "=", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "F", ".", "getSubtarget", "(", ")", ")", ";", "const", "MipsInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "LongBranchSeqSize", "=", "!", "IsPIC", "?", "2", ":", "(", "ABI", ".", "IsN64", "(", ")", "?", "10", ":", "(", "!", "STI", ".", "isTargetNaCl", "(", ")", "?", "9", ":", "10", ")", ")", ";", "if", "(", "STI", ".", "inMips16Mode", "(", ")", "||", "!", "STI", ".", "enableLongBranchPass", "(", ")", ")", "return", "false", ";", "if", "(", "IsPIC", "&&", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "TM", ")", ".", "getABI", "(", ")", ".", "IsO32", "(", ")", "&&", "F", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "globalBaseRegSet", "(", ")", ")", "emitGPDisp", "(", "F", ",", "TII", ")", ";", "if", "(", "SkipLongBranch", ")", "return", "true", ";", "MF", "=", "&", "F", ";", "initMBBInfo", "(", ")", ";", "SmallVectorImpl", "<", "MBBInfo", ">", "::", "iterator", "I", ",", "E", "=", "MBBInfos", ".", "end", "(", ")", ";", "bool", "EverMadeChange", "=", "false", ",", "MadeChange", "=", "true", ";", "while", "(", "MadeChange", ")", "{", "MadeChange", "=", "false", ";", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "Br", "||", "I", "->", "HasLongBranch", ")", "continue", ";", "int", "ShVal", "=", "STI", ".", "inMicroMipsMode", "(", ")", "?", "2", ":", "4", ";", "int64_t", "Offset", "=", "computeOffset", "(", "I", "->", "Br", ")", "/", "ShVal", ";", "if", "(", "STI", ".", "isTargetNaCl", "(", ")", ")", "{", "Offset", "*=", "2", ";", "}", "if", "(", "!", "ForceLongBranch", "&&", "isInt", "<", "16", ">", "(", "Offset", ")", ")", "continue", ";", "I", "->", "HasLongBranch", "=", "true", ";", "I", "->", "Size", "+=", "LongBranchSeqSize", "*", "4", ";", "++", "LongBranches", ";", "EverMadeChange", "=", "MadeChange", "=", "true", ";", "}", "}", "if", "(", "!", "EverMadeChange", ")", "return", "true", ";", "if", "(", "IsPIC", ")", "{", "uint64_t", "Address", "=", "0", ";", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "Address", "+=", "I", "->", "Size", ",", "++", "I", ")", "I", "->", "Address", "=", "Address", ";", "}", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "I", "->", "HasLongBranch", ")", "expandToLongBranch", "(", "*", "I", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "2", "10", "9", "10", "Mips", "Mips", "Mips", "Mips", "2", "4", "2", "16", "4", "0" ]

[]

[ "<s>", "static", "void", "arm_print_condition", "(", "FILE", "*", "stream", ")", "{", "if", "(", "arm_ccfsm_state", "==", "3", "||", "arm_ccfsm_state", "==", "4", ")", "{", "if", "(", "TARGET_THUMB", ")", "{", "output_operand_lossage", "(", "\"predicated Thumb instruction\"", ")", ";", "return", ";", "}", "if", "(", "current_insn_predicate", "!=", "NULL", ")", "{", "output_operand_lossage", "(", "\"predicated instruction in conditional sequence\"", ")", ";", "return", ";", "}", "fputs", "(", "arm_condition_codes", "[", "arm_current_cc", "]", ",", "stream", ")", ";", "}", "else", "if", "(", "current_insn_predicate", ")", "{", "enum", "arm_cond_code", "code", ";", "if", "(", "TARGET_THUMB1", ")", "{", "output_operand_lossage", "(", "\"predicated Thumb instruction\"", ")", ";", "return", ";", "}", "code", "=", "get_arm_condition_code", "(", "current_insn_predicate", ")", ";", "fputs", "(", "arm_condition_codes", "[", "code", "]", ",", "stream", ")", ";", "}", "}", "</s>" ]

[ "Print", "condition", "code", "to", "STREAM", ".", "Helper", "function", "for", "arm_print_operand", "." ]

[ "arm", "3", "4", "\"predicated Thumb instruction\"", "\"predicated instruction in conditional sequence\"", "\"predicated Thumb instruction\"" ]

[]

[ "<s>", "static", "void", "nvptx_output_barrier", "(", "rtx", "*", "mem_operand", ",", "int", "memmodel", ",", "bool", "pre_p", ")", "{", "bool", "post_p", "=", "!", "pre_p", ";", "switch", "(", "memmodel", ")", "{", "case", "MEMMODEL_RELAXED", ":", "return", ";", "case", "MEMMODEL_CONSUME", ":", "case", "MEMMODEL_ACQUIRE", ":", "case", "MEMMODEL_SYNC_ACQUIRE", ":", "if", "(", "post_p", ")", "break", ";", "return", ";", "case", "MEMMODEL_RELEASE", ":", "case", "MEMMODEL_SYNC_RELEASE", ":", "if", "(", "pre_p", ")", "break", ";", "return", ";", "case", "MEMMODEL_ACQ_REL", ":", "case", "MEMMODEL_SEQ_CST", ":", "case", "MEMMODEL_SYNC_SEQ_CST", ":", "if", "(", "pre_p", "||", "post_p", ")", "break", ";", "return", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "output_asm_insn", "(", "\"%.\\tmembar%B0;\"", ",", "mem_operand", ")", ";", "}", "</s>" ]

[ "Output", "a", "pre/post", "barrier", "for", "MEM_OPERAND", "according", "to", "MEMMODEL", "." ]

[ "nvptx", "\"%.\\tmembar%B0;\"" ]

[]

[ "<s>", "static", "void", "s390_conditional_register_usage", "(", "void", ")", "{", "int", "i", ";", "if", "(", "flag_pic", ")", "fixed_regs", "[", "PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "fixed_regs", "[", "BASE_REGNUM", "]", "=", "0", ";", "fixed_regs", "[", "RETURN_REGNUM", "]", "=", "0", ";", "if", "(", "TARGET_64BIT", ")", "{", "for", "(", "i", "=", "FPR8_REGNUM", ";", "i", "<=", "FPR15_REGNUM", ";", "i", "++", ")", "call_used_regs", "[", "i", "]", "=", "0", ";", "}", "else", "{", "call_used_regs", "[", "FPR4_REGNUM", "]", "=", "0", ";", "call_used_regs", "[", "FPR6_REGNUM", "]", "=", "0", ";", "}", "if", "(", "TARGET_SOFT_FLOAT", ")", "{", "for", "(", "i", "=", "FPR0_REGNUM", ";", "i", "<=", "FPR15_REGNUM", ";", "i", "++", ")", "fixed_regs", "[", "i", "]", "=", "1", ";", "}", "if", "(", "!", "TARGET_VX", ")", "{", "for", "(", "i", "=", "VR16_REGNUM", ";", "i", "<=", "VR31_REGNUM", ";", "i", "++", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "1", ";", "}", "}", "</s>" ]

[ "Implement", "CONDITIONAL_REGISTER_USAGE", "." ]

[ "s390", "1", "0", "0", "0", "0", "0", "1", "1" ]

[]

[ "<s>", "void", "mips_expand_vec_reduc", "(", "rtx", "target", ",", "rtx", "in", ",", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ")", "{", "machine_mode", "vmode", "=", "GET_MODE", "(", "in", ")", ";", "unsigned", "char", "perm2", "[", "2", "]", ";", "rtx", "last", ",", "next", ",", "fold", ",", "x", ";", "bool", "ok", ";", "last", "=", "in", ";", "fold", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "switch", "(", "vmode", ")", "{", "case", "E_V2SFmode", ":", "perm2", "[", "0", "]", "=", "1", ";", "perm2", "[", "1", "]", "=", "2", ";", "ok", "=", "mips_expand_vselect_vconcat", "(", "fold", ",", "last", ",", "last", ",", "perm2", ",", "2", ")", ";", "gcc_assert", "(", "ok", ")", ";", "break", ";", "case", "E_V2SImode", ":", "emit_insn", "(", "gen_loongson_punpckhwd", "(", "fold", ",", "last", ",", "last", ")", ")", ";", "break", ";", "case", "E_V4HImode", ":", "emit_insn", "(", "gen_loongson_punpckhwd_hi", "(", "fold", ",", "last", ",", "last", ")", ")", ";", "next", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "emit_insn", "(", "gen", "(", "next", ",", "last", ",", "fold", ")", ")", ";", "last", "=", "next", ";", "fold", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "x", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "16", ")", ")", ";", "emit_insn", "(", "gen_vec_shr_v4hi", "(", "fold", ",", "last", ",", "x", ")", ")", ";", "break", ";", "case", "E_V8QImode", ":", "emit_insn", "(", "gen_loongson_punpckhwd_qi", "(", "fold", ",", "last", ",", "last", ")", ")", ";", "next", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "emit_insn", "(", "gen", "(", "next", ",", "last", ",", "fold", ")", ")", ";", "last", "=", "next", ";", "fold", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "x", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "16", ")", ")", ";", "emit_insn", "(", "gen_vec_shr_v8qi", "(", "fold", ",", "last", ",", "x", ")", ")", ";", "next", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "emit_insn", "(", "gen", "(", "next", ",", "last", ",", "fold", ")", ")", ";", "last", "=", "next", ";", "fold", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "x", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "8", ")", ")", ";", "emit_insn", "(", "gen_vec_shr_v8qi", "(", "fold", ",", "last", ",", "x", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen", "(", "target", ",", "last", ",", "fold", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "vector", "reduction", "." ]

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

[]

[ "<s>", "static", "void", "ix86_emit_restore_regs_using_mov", "(", "HOST_WIDE_INT", "cfa_offset", ",", "bool", "maybe_eh_return", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "unsigned", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "!", "SSE_REGNO_P", "(", "regno", ")", "&&", "ix86_save_reg", "(", "regno", ",", "maybe_eh_return", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "word_mode", ",", "regno", ")", ";", "rtx", "insn", ",", "mem", ";", "mem", "=", "choose_baseaddr", "(", "cfa_offset", ")", ";", "mem", "=", "gen_frame_mem", "(", "word_mode", ",", "mem", ")", ";", "insn", "=", "emit_move_insn", "(", "reg", ",", "mem", ")", ";", "if", "(", "m", "->", "fs", ".", "cfa_reg", "==", "crtl", "->", "drap_reg", "&&", "regno", "==", "REGNO", "(", "crtl", "->", "drap_reg", ")", ")", "{", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "m", "->", "fs", ".", "drap_valid", "=", "true", ";", "}", "else", "ix86_add_cfa_restore_note", "(", "NULL_RTX", ",", "reg", ",", "cfa_offset", ")", ";", "cfa_offset", "-=", "UNITS_PER_WORD", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "restore", "saved", "registers", "using", "MOV", "insns", ".", "First", "register", "is", "restored", "from", "POINTER", "+", "OFFSET", "." ]

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

[]

[ "<s>", "static", "int", "ix86_function_regparm", "(", "const_tree", "type", ",", "const_tree", "decl", ")", "{", "tree", "attr", ";", "int", "regparm", ";", "unsigned", "int", "ccvt", ";", "if", "(", "TARGET_64BIT", ")", "return", "(", "ix86_function_type_abi", "(", "type", ")", "==", "SYSV_ABI", "?", "X86_64_REGPARM_MAX", ":", "X86_64_MS_REGPARM_MAX", ")", ";", "ccvt", "=", "ix86_get_callcvt", "(", "type", ")", ";", "regparm", "=", "ix86_regparm", ";", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_REGPARM", ")", "!=", "0", ")", "{", "attr", "=", "lookup_attribute", "(", "\"regparm\"", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ";", "if", "(", "attr", ")", "{", "regparm", "=", "TREE_INT_CST_LOW", "(", "TREE_VALUE", "(", "TREE_VALUE", "(", "attr", ")", ")", ")", ";", "return", "regparm", ";", "}", "}", "else", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_FASTCALL", ")", "!=", "0", ")", "return", "2", ";", "else", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_THISCALL", ")", "!=", "0", ")", "return", "1", ";", "if", "(", "decl", "&&", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "{", "cgraph_node", "*", "target", "=", "cgraph_node", "::", "get", "(", "decl", ")", ";", "if", "(", "target", ")", "target", "=", "target", "->", "function_symbol", "(", ")", ";", "if", "(", "target", "&&", "opt_for_fn", "(", "target", "->", "decl", ",", "optimize", ")", "&&", "!", "(", "profile_flag", "&&", "!", "flag_fentry", ")", ")", "{", "cgraph_local_info", "*", "i", "=", "&", "target", "->", "local", ";", "if", "(", "i", "&&", "i", "->", "local", "&&", "i", "->", "can_change_signature", ")", "{", "int", "local_regparm", ",", "globals", "=", "0", ",", "regno", ";", "for", "(", "local_regparm", "=", "0", ";", "local_regparm", "<", "REGPARM_MAX", ";", "local_regparm", "++", ")", "if", "(", "fixed_regs", "[", "local_regparm", "]", ")", "break", ";", "if", "(", "local_regparm", "==", "3", "&&", "DECL_STATIC_CHAIN", "(", "target", "->", "decl", ")", ")", "local_regparm", "=", "2", ";", "if", "(", "flag_split_stack", ")", "{", "if", "(", "local_regparm", "==", "3", ")", "local_regparm", "=", "2", ";", "else", "if", "(", "local_regparm", "==", "2", "&&", "DECL_STATIC_CHAIN", "(", "target", "->", "decl", ")", ")", "local_regparm", "=", "1", ";", "}", "for", "(", "regno", "=", "AX_REG", ";", "regno", "<=", "DI_REG", ";", "regno", "++", ")", "if", "(", "fixed_regs", "[", "regno", "]", ")", "globals", "++", ";", "local_regparm", "=", "globals", "<", "local_regparm", "?", "local_regparm", "-", "globals", ":", "0", ";", "if", "(", "local_regparm", ">", "regparm", ")", "regparm", "=", "local_regparm", ";", "}", "}", "}", "return", "regparm", ";", "}", "</s>" ]

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

[ "i386", "0", "\"regparm\"", "0", "2", "0", "1", "0", "0", "3", "2", "3", "2", "2", "1", "0" ]

[]

[ "<s>", "std", "::", "pair", "<", "EVT", ",", "EVT", ">", "AMDGPUTargetLowering", "::", "getSplitDestVTs", "(", "const", "EVT", "&", "VT", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "LoVT", ",", "HiVT", ";", "EVT", "EltVT", "=", "VT", ".", "getVectorElementType", "(", ")", ";", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "unsigned", "LoNumElts", "=", "PowerOf2Ceil", "(", "(", "NumElts", "+", "1", ")", "/", "2", ")", ";", "LoVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "EltVT", ",", "LoNumElts", ")", ";", "HiVT", "=", "NumElts", "-", "LoNumElts", "==", "1", "?", "EltVT", ":", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "EltVT", ",", "NumElts", "-", "LoNumElts", ")", ";", "return", "std", "::", "make_pair", "(", "LoVT", ",", "HiVT", ")", ";", "}", "</s>" ]

[ "Split", "a", "vector", "type", "into", "two", "parts", "." ]

[ "AMDGPU", "AMDGPU", "1", "2", "1" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "GCNHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "SIInstrInfo", "::", "isSMRD", "(", "*", "MI", ")", "&&", "checkSMRDHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "SIInstrInfo", "::", "isVMEM", "(", "*", "MI", ")", "&&", "checkVMEMHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "SIInstrInfo", "::", "isVALU", "(", "*", "MI", ")", "&&", "checkVALUHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "SIInstrInfo", "::", "isDPP", "(", "*", "MI", ")", "&&", "checkDPPHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isDivFMas", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkDivFMasHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isRWLane", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkRWLaneHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isSGetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkGetRegHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isSSetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkSetRegHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isRFE", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkRFEHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "return", "NoHazard", ";", "}", "</s>" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

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

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "isProfitableToIfCvt", "(", "MachineBasicBlock", "&", "TMBB", ",", "unsigned", "NumCyclesT", ",", "unsigned", "ExtraPredCyclesT", ",", "MachineBasicBlock", "&", "FMBB", ",", "unsigned", "NumCyclesF", ",", "unsigned", "ExtraPredCyclesF", ",", "BranchProbability", "Probability", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Second", "variant", "of", "isProfitableToIfCvt", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Dead register definitions\"", ";", "}", "</s>" ]

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

[ "AArch64", "\"Dead register definitions\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "HexagonTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "bool", "UseHVX", "=", "Subtarget", ".", "useHVXOps", "(", ")", ",", "UseHVXDbl", "=", "Subtarget", ".", "useHVXDblOps", "(", ")", ";", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "llvm_unreachable", "(", "\"getRegForInlineAsmConstraint Unhandled data type\"", ")", ";", "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "f32", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Hexagon", "::", "IntRegsRegClass", ")", ";", "case", "MVT", "::", "i64", ":", "case", "MVT", "::", "f64", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Hexagon", "::", "DoubleRegsRegClass", ")", ";", "}", "break", ";", "case", "'a'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Hexagon", "::", "ModRegsRegClass", ")", ";", "case", "'q'", ":", "switch", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"getRegForInlineAsmConstraint Unhandled vector size\"", ")", ";", "case", "512", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Hexagon", "::", "HvxQRRegClass", ")", ";", "case", "1024", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Hexagon", "::", "HvxQRRegClass", ")", ";", "}", "break", ";", "case", "'v'", ":", "switch", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"getRegForInlineAsmConstraint Unhandled vector size\"", ")", ";", "case", "512", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Hexagon", "::", "HvxVRRegClass", ")", ";", "case", "1024", ":", "if", "(", "Subtarget", ".", "hasV60TOps", "(", ")", "&&", "UseHVX", "&&", "UseHVXDbl", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Hexagon", "::", "HvxVRRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Hexagon", "::", "HvxWRRegClass", ")", ";", "case", "2048", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Hexagon", "::", "HvxWRRegClass", ")", ";", "}", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unknown asm register class\"", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "1", "0", "\"getRegForInlineAsmConstraint Unhandled data type\"", "MVT::i1", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::f32", "0U", "Hexagon::IntRegsRegClass", "MVT::i64", "MVT::f64", "0U", "Hexagon::DoubleRegsRegClass", "0U", "Hexagon::ModRegsRegClass", "\"getRegForInlineAsmConstraint Unhandled vector size\"", "512", "0U", "Hexagon::HvxQRRegClass", "1024", "0U", "Hexagon::HvxQRRegClass", "\"getRegForInlineAsmConstraint Unhandled vector size\"", "512", "0U", "Hexagon::HvxVRRegClass", "1024", "0U", "Hexagon::HvxVRRegClass", "0U", "Hexagon::HvxWRRegClass", "2048", "0U", "Hexagon::HvxWRRegClass", "\"Unknown asm register class\"" ]

[]

[ "<s>", "static", "int", "ix86_register_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "class1_i", ",", "reg_class_t", "class2_i", ")", "{", "enum", "reg_class", "class1", "=", "(", "enum", "reg_class", ")", "class1_i", ";", "enum", "reg_class", "class2", "=", "(", "enum", "reg_class", ")", "class2_i", ";", "if", "(", "inline_secondary_memory_needed", "(", "mode", ",", "class1", ",", "class2", ",", "false", ")", ")", "{", "int", "cost", "=", "1", ";", "cost", "+=", "inline_memory_move_cost", "(", "mode", ",", "class1", ",", "2", ")", ";", "cost", "+=", "inline_memory_move_cost", "(", "mode", ",", "class2", ",", "2", ")", ";", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ">", "BITS_PER_WORD", "&&", "TARGET_MEMORY_MISMATCH_STALL", "&&", "targetm", ".", "class_max_nregs", "(", "class1", ",", "mode", ")", ">", "targetm", ".", "class_max_nregs", "(", "class2", ",", "mode", ")", ")", "cost", "+=", "20", ";", "if", "(", "(", "MMX_CLASS_P", "(", "class1", ")", "&&", "MAYBE_FLOAT_CLASS_P", "(", "class2", ")", ")", "||", "(", "MMX_CLASS_P", "(", "class2", ")", "&&", "MAYBE_FLOAT_CLASS_P", "(", "class1", ")", ")", ")", "cost", "+=", "20", ";", "return", "cost", ";", "}", "if", "(", "MMX_CLASS_P", "(", "class1", ")", "!=", "MMX_CLASS_P", "(", "class2", ")", ")", "gcc_unreachable", "(", ")", ";", "if", "(", "SSE_CLASS_P", "(", "class1", ")", "!=", "SSE_CLASS_P", "(", "class2", ")", ")", "return", "(", "SSE_CLASS_P", "(", "class1", ")", "?", "ix86_cost", "->", "hard_register", ".", "sse_to_integer", ":", "ix86_cost", "->", "hard_register", ".", "integer_to_sse", ")", ";", "if", "(", "MASK_CLASS_P", "(", "class1", ")", "!=", "MASK_CLASS_P", "(", "class2", ")", ")", "{", "return", "(", "MASK_CLASS_P", "(", "class1", ")", "?", "ix86_cost", "->", "hard_register", ".", "mask_to_integer", ":", "ix86_cost", "->", "hard_register", ".", "integer_to_mask", ")", ";", "}", "if", "(", "MASK_CLASS_P", "(", "class1", ")", "&&", "MASK_CLASS_P", "(", "class2", ")", ")", "return", "ix86_cost", "->", "hard_register", ".", "mask_move", ";", "if", "(", "MAYBE_FLOAT_CLASS_P", "(", "class1", ")", ")", "return", "ix86_cost", "->", "hard_register", ".", "fp_move", ";", "if", "(", "MAYBE_SSE_CLASS_P", "(", "class1", ")", ")", "{", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "<=", "128", ")", "return", "ix86_cost", "->", "hard_register", ".", "xmm_move", ";", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "<=", "256", ")", "return", "ix86_cost", "->", "hard_register", ".", "ymm_move", ";", "return", "ix86_cost", "->", "hard_register", ".", "zmm_move", ";", "}", "if", "(", "MAYBE_MMX_CLASS_P", "(", "class1", ")", ")", "return", "ix86_cost", "->", "hard_register", ".", "mmx_move", ";", "return", "2", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "moving", "data", "from", "a", "register", "in", "class", "CLASS1", "to", "one", "in", "class", "CLASS2", ".", "It", "is", "not", "required", "that", "the", "cost", "always", "equal", "2", "when", "FROM", "is", "the", "same", "as", "TO", ";", "on", "some", "machines", "it", "is", "expensive", "to", "move", "between", "registers", "if", "they", "are", "not", "general", "registers", "." ]

[ "i386", "1", "2", "2", "20", "20", "128", "256", "2" ]

[]

[ "<s>", "static", "bool", "rs6000_output_addr_const_extra", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_TOCREL", ":", "gcc_checking_assert", "(", "SYMBOL_REF_P", "(", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", "&&", "REG_P", "(", "XVECEXP", "(", "x", ",", "0", ",", "1", ")", ")", "&&", "REGNO", "(", "XVECEXP", "(", "x", ",", "0", ",", "1", ")", ")", "==", "TOC_REGISTER", ")", ";", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "if", "(", "x", "==", "tocrel_base_oac", "&&", "tocrel_offset_oac", "!=", "const0_rtx", ")", "{", "if", "(", "INTVAL", "(", "tocrel_offset_oac", ")", ">=", "0", ")", "fprintf", "(", "file", ",", "\"+\"", ")", ";", "output_addr_const", "(", "file", ",", "CONST_CAST_RTX", "(", "tocrel_offset_oac", ")", ")", ";", "}", "if", "(", "!", "TARGET_AIX", "||", "(", "TARGET_ELF", "&&", "TARGET_MINIMAL_TOC", ")", ")", "{", "putc", "(", "'-'", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "toc_label_name", ")", ";", "need_toc_init", "=", "1", ";", "}", "else", "if", "(", "TARGET_ELF", ")", "fputs", "(", "\"@toc\"", ",", "file", ")", ";", "return", "true", ";", "case", "UNSPEC_MACHOPIC_OFFSET", ":", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "putc", "(", "'-'", ",", "file", ")", ";", "machopic_output_function_base_name", "(", "file", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA", "." ]

[ "rs6000", "1", "0", "0", "0", "1", "0", "1", "0", "0", "0", "\"+\"", "1", "\"@toc\"", "0", "0" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isExtended", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "const", "uint64_t", "F", "=", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", ";", "if", "(", "(", "F", ">>", "HexagonII", "::", "ExtendedPos", ")", "&", "HexagonII", "::", "ExtendedMask", ")", "return", "true", ";", "for", "(", "MachineInstr", "::", "const_mop_iterator", "I", "=", "MI", "->", "operands_begin", "(", ")", ",", "E", "=", "MI", "->", "operands_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "getTargetFlags", "(", ")", "&&", "HexagonII", "::", "HMOTF_ConstExtended", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Test", "if", "the", "given", "EVT", "is", "extended", "(", "as", "opposed", "to", "being", "simple", ")", "." ]

[ "Hexagon", "Hexagon", "HexagonII::ExtendedPos", "HexagonII::ExtendedMask", "HexagonII::HMOTF_ConstExtended" ]

[]

[ "<s>", "void", "cr16_expand_prologue", "(", "void", ")", "{", "rtx", "insn", ";", "cr16_compute_frame", "(", ")", ";", "cr16_compute_save_regs", "(", ")", ";", "if", "(", "(", "current_frame_info", ".", "total_size", "+", "current_frame_info", ".", "reg_size", ")", "==", "0", ")", "return", ";", "if", "(", "current_frame_info", ".", "last_reg_to_save", "!=", "-", "1", ")", "{", "insn", "=", "emit_insn", "(", "gen_push_for_prologue", "(", "GEN_INT", "(", "current_frame_info", ".", "reg_size", ")", ")", ")", ";", "cr16_create_dwarf_for_multi_push", "(", "insn", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "if", "(", "current_frame_info", ".", "total_size", ">", "0", ")", "{", "insn", "=", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "current_frame_info", ".", "total_size", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "if", "(", "frame_pointer_needed", ")", "{", "insn", "=", "emit_move_insn", "(", "frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "}", "}", "</s>" ]

[ "CompactRISC", "CR16", "Architecture", "stack", "layout", ":", "0", "+", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-", "|", ".", ".", "|", "+====================", "Sp", "(", "x", ")", "=", "Ap", "(", "x+1", ")", "A", "|", "Args", "for", "functions", "|", "|", "called", "by", "X", "and", "Dynamically", "|", "|", "Dynamic", "allocations", "allocated", "and", "|", "|", "(", "alloca", ",", "variable", "deallocated", "Stack", "|", "length", "arrays", ")", ".", "grows", "+", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "Fp", "(", "x", ")", "down|", "|", "Local", "variables", "of", "X", "ward|", "+", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "|", "|", "Regs", "saved", "for", "X-1", "|", "+====================", "Sp", "(", "x-1", ")", "=", "Ap", "(", "x", ")", "|", "Args", "for", "func", "X", "|", "pushed", "by", "X-1", "+", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "Fp", "(", "x-1", ")", "|", "|", "V" ]

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

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "isPredicable", "(", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "STI", ".", "hasLoadStoreOnCond", "(", ")", "&&", "getConditionalMove", "(", "Opcode", ")", ")", "return", "true", ";", "if", "(", "Opcode", "==", "SystemZ", "::", "Return", "||", "Opcode", "==", "SystemZ", "::", "Trap", "||", "Opcode", "==", "SystemZ", "::", "CallJG", "||", "Opcode", "==", "SystemZ", "::", "CallBR", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ::Return", "SystemZ::Trap", "SystemZ::CallJG", "SystemZ::CallBR" ]

[]

[ "<s>", "static", "void", "iq2000_option_override", "(", "void", ")", "{", "target_flags", "&=", "~", "MASK_GPOPT", ";", "iq2000_isa", "=", "IQ2000_ISA_DEFAULT", ";", "iq2000_print_operand_punct", "[", "'?'", "]", "=", "1", ";", "iq2000_print_operand_punct", "[", "'#'", "]", "=", "1", ";", "iq2000_print_operand_punct", "[", "'&'", "]", "=", "1", ";", "iq2000_print_operand_punct", "[", "'!'", "]", "=", "1", ";", "iq2000_print_operand_punct", "[", "'*'", "]", "=", "1", ";", "iq2000_print_operand_punct", "[", "'@'", "]", "=", "1", ";", "iq2000_print_operand_punct", "[", "'.'", "]", "=", "1", ";", "iq2000_print_operand_punct", "[", "'('", "]", "=", "1", ";", "iq2000_print_operand_punct", "[", "')'", "]", "=", "1", ";", "iq2000_print_operand_punct", "[", "'['", "]", "=", "1", ";", "iq2000_print_operand_punct", "[", "']'", "]", "=", "1", ";", "iq2000_print_operand_punct", "[", "'<'", "]", "=", "1", ";", "iq2000_print_operand_punct", "[", "'>'", "]", "=", "1", ";", "iq2000_print_operand_punct", "[", "'{'", "]", "=", "1", ";", "iq2000_print_operand_punct", "[", "'}'", "]", "=", "1", ";", "iq2000_print_operand_punct", "[", "'^'", "]", "=", "1", ";", "iq2000_print_operand_punct", "[", "'$'", "]", "=", "1", ";", "iq2000_print_operand_punct", "[", "'+'", "]", "=", "1", ";", "iq2000_print_operand_punct", "[", "'~'", "]", "=", "1", ";", "gpr_mode", "=", "SImode", ";", "init_machine_status", "=", "iq2000_init_machine_status", ";", "}", "</s>" ]

[ "Detect", "any", "conflicts", "in", "the", "switches", "." ]

[ "iq2000", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "static", "void", "expand_block_set_2", "(", "rtx", "dst", ",", "rtx", "dst_reg", ",", "rtx", "value_rtx", ",", "rtx", "bytes_rtx", ")", "{", "const", "rtx", "sym", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__wrd_memset\"", ")", ";", "unsigned", "HOST_WIDE_INT", "bytes", "=", "UINTVAL", "(", "bytes_rtx", ")", ";", "unsigned", "int", "rem", "=", "bytes", "%", "2", ";", "value_rtx", "=", "convert_to_mode", "(", "Pmode", ",", "value_rtx", ",", "1", ")", ";", "emit_library_call", "(", "sym", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "3", ",", "dst_reg", ",", "Pmode", ",", "value_rtx", ",", "Pmode", ",", "convert_to_mode", "(", "TYPE_MODE", "(", "sizetype", ")", ",", "GEN_INT", "(", "bytes", ">>", "1", ")", ",", "TYPE_UNSIGNED", "(", "sizetype", ")", ")", ",", "TYPE_MODE", "(", "sizetype", ")", ")", ";", "if", "(", "rem", "==", "0", ")", "return", ";", "dst", "=", "replace_equiv_address_nv", "(", "dst", ",", "dst_reg", ")", ";", "bytes", "-=", "rem", ";", "emit_move_insn", "(", "adjust_address_nv", "(", "dst", ",", "QImode", ",", "bytes", ")", ",", "convert_to_mode", "(", "QImode", ",", "value_rtx", ",", "1", ")", ")", ";", "}", "</s>" ]

[ "Generate", "a", "call", "to", "a", "library", "function", "to", "set", "BYTES_RTX", "bytes", "of", "DST", "with", "address", "DST_REG", "to", "VALUE_RTX", "in", "2-byte", "chunks", "." ]

[ "visium", "\"__wrd_memset\"", "2", "1", "3", "1", "0", "1" ]

[]

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

[ "Return", "true", "when", "a", "target", "supports", "MachineCombiner", "." ]

[ "X86" ]

[]

[ "<s>", "size_t", "Mips64GOT", "::", "getEntrySize", "(", ")", "const", "{", "return", "Mips64GOTEntry", "::", "EntrySize", ";", "}", "</s>" ]

[ "getEntrySize", "-", "Return", "the", "size", "of", "each", "entry", "in", "the", "jump", "table", "." ]

[ "Mips", "Mips", "Mips64GOTEntry::EntrySize" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected Kind in getPointerRegClass!\"", ")", ";", "case", "0", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", ")", "return", "&", "X86", "::", "GR64RegClass", ";", "return", "&", "X86", "::", "GR32RegClass", ";", "case", "1", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOSPRegClass", ";", "return", "&", "X86", "::", "GR32_NOSPRegClass", ";", "case", "2", ":", "if", "(", "Subtarget", ".", "isTargetWin64", "(", ")", ")", "return", "&", "X86", "::", "GR64_TCW64RegClass", ";", "else", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "return", "&", "X86", "::", "GR64_TCRegClass", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "hasHipeCC", "=", "(", "F", "?", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "HiPE", ":", "false", ")", ";", "if", "(", "hasHipeCC", ")", "return", "&", "X86", "::", "GR32RegClass", ";", "return", "&", "X86", "::", "GR32_TCRegClass", ";", "}", "}", "</s>" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ "X86", "X86", "\"Unexpected Kind in getPointerRegClass!\"", "0", "X86::GR64RegClass", "X86::GR32RegClass", "1", "X86::GR64_NOSPRegClass", "X86::GR32_NOSPRegClass", "2", "X86::GR64_TCW64RegClass", "X86::GR64_TCRegClass", "X86::GR32RegClass", "X86::GR32_TCRegClass" ]

[]

[ "<s>", "unsigned", "AVRInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "{", "continue", ";", "}", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "AVR", "::", "RJMPk", "&&", "getCondFromBranchOpc", "(", "I", "->", "getOpcode", "(", ")", ")", "==", "AVRCC", "::", "COND_INVALID", ")", "{", "break", ";", "}", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "AVR", "AVR", "\"code size not handled\"", "0", "AVR::RJMPk", "AVRCC::COND_INVALID" ]

[]

[ "<s>", "static", "int", "ix86_nsaved_regs", "(", "void", ")", "{", "int", "nregs", "=", "0", ";", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "!", "SSE_REGNO_P", "(", "regno", ")", "&&", "ix86_save_reg", "(", "regno", ",", "true", ")", ")", "nregs", "++", ";", "return", "nregs", ";", "}", "</s>" ]

[ "Return", "number", "of", "registers", "to", "be", "saved", "on", "the", "stack", "." ]

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

[]

[ "<s>", "static", "void", "*", "rs6000_alloc_sched_context", "(", "void", ")", "{", "return", "xmalloc", "(", "sizeof", "(", "rs6000_sched_context_def", ")", ")", ";", "}", "</s>" ]

[ "Allocate", "store", "for", "new", "scheduling", "context", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "static", "void", "nds32_asm_trampoline_template", "(", "FILE", "*", "f", ")", "{", "if", "(", "TARGET_REDUCED_REGS", ")", "{", "sorry", "(", "\"a nested function is not supported for reduced registers\"", ")", ";", "}", "else", "{", "asm_fprintf", "(", "f", ",", "\"\\t! Trampoline code template\\n\"", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\t! This code fragment will be copied \"", "\"into stack on demand\\n\"", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tmfusr\\t$r16,$pc\\n\"", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tlwi\\t$r15,[$r16 + 20] \"", "\"! load nested function address\\n\"", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tlwi\\t$r16,[$r16 + 16] \"", "\"! load chain_value\\n\"", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tjr\\t$r15\\n\"", ")", ";", "}", "asm_fprintf", "(", "f", ",", "\"\\t! space for saving chain_value\\n\"", ")", ";", "assemble_aligned_integer", "(", "UNITS_PER_WORD", ",", "const0_rtx", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\t! space for saving nested function address\\n\"", ")", ";", "assemble_aligned_integer", "(", "UNITS_PER_WORD", ",", "const0_rtx", ")", ";", "}", "</s>" ]

[ "Trampolines", "for", "Nested", "Functions", "." ]

[ "nds32", "\"a nested function is not supported for reduced registers\"", "\"\\t! Trampoline code template\\n\"", "\"\\t! This code fragment will be copied \"", "\"into stack on demand\\n\"", "\"\\tmfusr\\t$r16,$pc\\n\"", "\"\\tlwi\\t$r15,[$r16 + 20] \"", "\"! load nested function address\\n\"", "\"\\tlwi\\t$r16,[$r16 + 16] \"", "\"! load chain_value\\n\"", "\"\\tjr\\t$r15\\n\"", "\"\\t! space for saving chain_value\\n\"", "\"\\t! space for saving nested function address\\n\"" ]

[]

[ "<s>", "EVT", "SystemZTargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "MVT", "::", "i32", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "MVT::i32" ]

[]

[ "<s>", "static", "std", "::", "string", "toString", "(", "const", "APFloat", "&", "FP", ")", "{", "if", "(", "FP", ".", "isNaN", "(", ")", "&&", "!", "FP", ".", "bitwiseIsEqual", "(", "APFloat", "::", "getQNaN", "(", "FP", ".", "getSemantics", "(", ")", ")", ")", "&&", "!", "FP", ".", "bitwiseIsEqual", "(", "APFloat", "::", "getQNaN", "(", "FP", ".", "getSemantics", "(", ")", ",", "true", ")", ")", ")", "{", "APInt", "AI", "=", "FP", ".", "bitcastToAPInt", "(", ")", ";", "return", "std", "::", "string", "(", "AI", ".", "isNegative", "(", ")", "?", "\"-\"", ":", "\"\"", ")", "+", "\"nan:0x\"", "+", "utohexstr", "(", "AI", ".", "getZExtValue", "(", ")", "&", "(", "AI", ".", "getBitWidth", "(", ")", "==", "32", "?", "INT64_C", "(", "0x007fffff", ")", ":", "INT64_C", "(", "0x000fffffffffffff", ")", ")", ",", "true", ")", ";", "}", "static", "const", "size_t", "BufBytes", "=", "128", ";", "char", "buf", "[", "BufBytes", "]", ";", "auto", "Written", "=", "FP", ".", "convertToHexString", "(", "buf", ",", "0", ",", "false", ",", "APFloat", "::", "rmNearestTiesToEven", ")", ";", "(", "void", ")", "Written", ";", "assert", "(", "Written", "!=", "0", ")", ";", "assert", "(", "Written", "<", "BufBytes", ")", ";", "return", "buf", ";", "}", "</s>" ]

[ "Convert", "to", "a", "decimal", "representation", "in", "a", "string", "." ]

[ "WebAssembly", "\"-\"", "\"\"", "\"nan:0x\"", "32", "0x007fffff", "0x000fffffffffffff", "128", "0", "0" ]

[]

[ "<s>", "int", "pru_can_use_return_insn", "(", "void", ")", "{", "if", "(", "!", "reload_completed", "||", "crtl", "->", "profile", ")", "return", "0", ";", "return", "cfun", "->", "machine", "->", "total_size", "==", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", ".", "This", "allows", "the", "optimizer", "to", "omit", "jumps", "to", "jumps", "if", "no", "stack", "was", "created", "." ]

[ "pru", "0", "0" ]

[]

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

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

[ "rs6000", "0" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "has128ByteRedZone", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "assert", "(", "&", "STI", "==", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", "&&", "\"MF used frame lowering for wrong subtarget\"", ")", ";", "const", "Function", "&", "Fn", "=", "MF", ".", "getFunction", "(", ")", ";", "const", "bool", "IsWin64CC", "=", "STI", ".", "isCallingConvWin64", "(", "Fn", ".", "getCallingConv", "(", ")", ")", ";", "return", "Is64Bit", "&&", "!", "IsWin64CC", "&&", "!", "Fn", ".", "hasFnAttribute", "(", "Attribute", "::", "NoRedZone", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "function", "has", "a", "redzone", "(", "accessible", "bytes", "past", "the", "frame", "of", "the", "top", "of", "stack", "function", ")", "as", "part", "of", "it", "'s", "ABI", "." ]

[ "X86", "X86", "X86", "\"MF used frame lowering for wrong subtarget\"" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isVectorLoadExtDesirable", "(", "SDValue", "ExtVal", ")", "const", "{", "return", "ExtVal", ".", "getValueType", "(", ")", ".", "isScalableVector", "(", ")", "||", "useSVEForFixedLengthVectorVT", "(", "ExtVal", ".", "getValueType", "(", ")", ",", "Subtarget", "->", "useSVEForFixedLengthVectors", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "vector", "load", "into", "ExtVal", "(", "a", "sign", ",", "zero", ",", "or", "any", "extend", "node", ")", "is", "profitable", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "unsigned", "size", "(", ")", "const", "{", "return", "(", "Packet", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

[ "The", "number", "of", "name/type", "pairs", "is", "returned", "." ]

[ "Hexagon" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "AArch64TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "GPR64commonRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "GPR32commonRegClass", ")", ";", "case", "'w'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "FPR32RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "FPR64RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "FPR128RegClass", ")", ";", "break", ";", "case", "'x'", ":", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "FPR128_loRegClass", ")", ";", "break", ";", "}", "}", "if", "(", "StringRef", "(", "\"{cc}\"", ")", ".", "equals_lower", "(", "Constraint", ")", ")", "return", "std", "::", "make_pair", "(", "unsigned", "(", "AArch64", "::", "NZCV", ")", ",", "&", "AArch64", "::", "CCRRegClass", ")", ";", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "Res", ";", "Res", "=", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "if", "(", "!", "Res", ".", "second", ")", "{", "unsigned", "Size", "=", "Constraint", ".", "size", "(", ")", ";", "if", "(", "(", "Size", "==", "4", "||", "Size", "==", "5", ")", "&&", "Constraint", "[", "0", "]", "==", "'{'", "&&", "tolower", "(", "Constraint", "[", "1", "]", ")", "==", "'v'", "&&", "Constraint", "[", "Size", "-", "1", "]", "==", "'}'", ")", "{", "int", "RegNo", ";", "bool", "Failed", "=", "Constraint", ".", "slice", "(", "2", ",", "Size", "-", "1", ")", ".", "getAsInteger", "(", "10", ",", "RegNo", ")", ";", "if", "(", "!", "Failed", "&&", "RegNo", ">=", "0", "&&", "RegNo", "<=", "31", ")", "{", "if", "(", "VT", "!=", "MVT", "::", "Other", "&&", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "{", "Res", ".", "first", "=", "AArch64", "::", "FPR64RegClass", ".", "getRegister", "(", "RegNo", ")", ";", "Res", ".", "second", "=", "&", "AArch64", "::", "FPR64RegClass", ";", "}", "else", "{", "Res", ".", "first", "=", "AArch64", "::", "FPR128RegClass", ".", "getRegister", "(", "RegNo", ")", ";", "Res", ".", "second", "=", "&", "AArch64", "::", "FPR128RegClass", ";", "}", "}", "}", "}", "return", "Res", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "1", "0", "64", "0U", "AArch64::GPR64commonRegClass", "0U", "AArch64::GPR32commonRegClass", "MVT::f32", "0U", "AArch64::FPR32RegClass", "64", "0U", "AArch64::FPR64RegClass", "128", "0U", "AArch64::FPR128RegClass", "128", "0U", "AArch64::FPR128_loRegClass", "\"{cc}\"", "AArch64::NZCV", "AArch64::CCRRegClass", "4", "5", "0", "1", "1", "2", "1", "10", "0", "31", "MVT::Other", "64", "AArch64::FPR64RegClass", "AArch64::FPR64RegClass", "AArch64::FPR128RegClass", "AArch64::FPR128RegClass" ]

[]

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

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "virtual", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "{", "return", "&", "InstrItins", ";", "}", "</s>" ]

[ "getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "." ]

[ "CellSPU" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "&", "MI", ",", "AAResults", "*", "AA", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "V_MOV_B32_e32", ":", "case", "AMDGPU", "::", "V_MOV_B32_e64", ":", "case", "AMDGPU", "::", "V_MOV_B64_PSEUDO", ":", "case", "AMDGPU", "::", "V_ACCVGPR_READ_B32_e64", ":", "case", "AMDGPU", "::", "V_ACCVGPR_WRITE_B32_e64", ":", "return", "MI", ".", "getNumOperands", "(", ")", "==", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "For", "instructions", "with", "opcodes", "for", "which", "the", "M_REMATERIALIZABLE", "flag", "is", "set", ",", "this", "hook", "lets", "the", "target", "specify", "whether", "the", "instruction", "is", "actually", "trivially", "rematerializable", ",", "taking", "into", "consideration", "its", "operands", "." ]

[ "AMDGPU", "SI", "AMDGPU::V_MOV_B32_e32", "AMDGPU::V_MOV_B32_e64", "AMDGPU::V_MOV_B64_PSEUDO", "AMDGPU::V_ACCVGPR_READ_B32_e64", "AMDGPU::V_ACCVGPR_WRITE_B32_e64" ]

[]

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

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

[ "LC3", "LC3" ]

[]

[ "<s>", "void", "NVPTXTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"Unhandled custom legalization\"", ")", ";", "case", "ISD", "::", "LOAD", ":", "ReplaceLoadVector", "(", "N", ",", "DAG", ",", "Results", ")", ";", "return", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "ReplaceINTRINSIC_W_CHAIN", "(", "N", ",", "DAG", ",", "Results", ")", ";", "return", ";", "}", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "\"Unhandled custom legalization\"", "ISD::LOAD", "ISD::INTRINSIC_W_CHAIN" ]

[]

[ "<s>", "bool", "arc_legitimate_pc_offset_p", "(", "rtx", "addr", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "CONST", ")", "return", "false", ";", "return", "arc_needs_pcl_p", "(", "addr", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "ADDR", "is", "an", "address", "that", "needs", "to", "be", "expressed", "as", "an", "explicit", "sum", "of", "pcl", "+", "offset", "." ]

[ "arc" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"R600 Packetizer\"", ";", "}", "</s>" ]

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

[ "R600", "\"R600 Packetizer\"" ]

[]

[ "<s>", "static", "inline", "ChildIteratorType", "child_begin", "(", "NodeRef", "N", ")", "{", "return", "N", "->", "G", "->", "Edges", ".", "lower_bound", "(", "N", ")", ";", "}", "</s>" ]

[ "nodes_iterator/begin/end", "-", "Allow", "iteration", "over", "all", "nodes", "in", "the", "graph" ]

[ "Patmos" ]

[]

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

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

[ "X86" ]

[]

[ "<s>", "void", "X86AsmPrinter", "::", "emitStartOfAsmFile", "(", "Module", "&", "M", ")", "{", "const", "Triple", "&", "TT", "=", "TM", ".", "getTargetTriple", "(", ")", ";", "if", "(", "TT", ".", "isOSBinFormatELF", "(", ")", ")", "{", "unsigned", "FeatureFlagsAnd", "=", "0", ";", "if", "(", "M", ".", "getModuleFlag", "(", "\"cf-protection-branch\"", ")", ")", "FeatureFlagsAnd", "|=", "ELF", "::", "GNU_PROPERTY_X86_FEATURE_1_IBT", ";", "if", "(", "M", ".", "getModuleFlag", "(", "\"cf-protection-return\"", ")", ")", "FeatureFlagsAnd", "|=", "ELF", "::", "GNU_PROPERTY_X86_FEATURE_1_SHSTK", ";", "if", "(", "FeatureFlagsAnd", ")", "{", "if", "(", "!", "TT", ".", "isArch32Bit", "(", ")", "&&", "!", "TT", ".", "isArch64Bit", "(", ")", ")", "llvm_unreachable", "(", "\"CFProtection used on invalid architecture!\"", ")", ";", "MCSection", "*", "Cur", "=", "OutStreamer", "->", "getCurrentSectionOnly", "(", ")", ";", "MCSection", "*", "Nt", "=", "MMI", "->", "getContext", "(", ")", ".", "getELFSection", "(", "\".note.gnu.property\"", ",", "ELF", "::", "SHT_NOTE", ",", "ELF", "::", "SHF_ALLOC", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Nt", ")", ";", "int", "WordSize", "=", "TT", ".", "isArch64Bit", "(", ")", "?", "8", ":", "4", ";", "emitAlignment", "(", "WordSize", "==", "4", "?", "Align", "(", "4", ")", ":", "Align", "(", "8", ")", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "4", ",", "4", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "8", "+", "WordSize", ",", "4", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "ELF", "::", "NT_GNU_PROPERTY_TYPE_0", ",", "4", ")", ";", "OutStreamer", "->", "emitBytes", "(", "StringRef", "(", "\"GNU\"", ",", "4", ")", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "ELF", "::", "GNU_PROPERTY_X86_FEATURE_1_AND", ",", "4", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "4", ",", "4", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "FeatureFlagsAnd", ",", "4", ")", ";", "emitAlignment", "(", "WordSize", "==", "4", "?", "Align", "(", "4", ")", ":", "Align", "(", "8", ")", ")", ";", "OutStreamer", "->", "endSection", "(", "Nt", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Cur", ")", ";", "}", "}", "if", "(", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "OutStreamer", "->", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getTextSection", "(", ")", ")", ";", "if", "(", "TT", ".", "isOSBinFormatCOFF", "(", ")", ")", "{", "MCSymbol", "*", "S", "=", "MMI", "->", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "StringRef", "(", "\"@feat.00\"", ")", ")", ";", "OutStreamer", "->", "BeginCOFFSymbolDef", "(", "S", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolStorageClass", "(", "COFF", "::", "IMAGE_SYM_CLASS_STATIC", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolType", "(", "COFF", "::", "IMAGE_SYM_DTYPE_NULL", ")", ";", "OutStreamer", "->", "EndCOFFSymbolDef", "(", ")", ";", "int64_t", "Feat00Flags", "=", "0", ";", "if", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", ")", "{", "Feat00Flags", "|=", "1", ";", "}", "if", "(", "M", ".", "getModuleFlag", "(", "\"cfguard\"", ")", ")", "Feat00Flags", "|=", "0x800", ";", "OutStreamer", "->", "emitSymbolAttribute", "(", "S", ",", "MCSA_Global", ")", ";", "OutStreamer", "->", "emitAssignment", "(", "S", ",", "MCConstantExpr", "::", "create", "(", "Feat00Flags", ",", "MMI", "->", "getContext", "(", ")", ")", ")", ";", "}", "OutStreamer", "->", "emitSyntaxDirective", "(", ")", ";", "bool", "is16", "=", "TT", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "CODE16", ";", "if", "(", "M", ".", "getModuleInlineAsm", "(", ")", ".", "empty", "(", ")", "&&", "is16", ")", "OutStreamer", "->", "emitAssemblerFlag", "(", "MCAF_Code16", ")", ";", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "start", "of", "their", "file", "." ]

[ "X86", "X86", "0", "\"cf-protection-branch\"", "X86", "\"cf-protection-return\"", "X86", "\"CFProtection used on invalid architecture!\"", "\".note.gnu.property\"", "8", "4", "4", "4", "8", "4", "4", "8", "4", "4", "\"GNU\"", "4", "X86", "4", "4", "4", "4", "4", "4", "8", "\"@feat.00\"", "0", "1", "\"cfguard\"", "0x800" ]

[]

[ "<s>", "static", "base_reg_disp", "sh_find_base_reg_disp", "(", "rtx_insn", "*", "insn", ",", "rtx", "x", ",", "disp_t", "disp", "=", "0", ",", "rtx", "base_reg", "=", "NULL", ")", "{", "if", "(", "REG_P", "(", "x", ")", ")", "{", "if", "(", "REGNO", "(", "x", ")", "==", "GBR_REG", ")", "return", "base_reg_disp", "(", "x", ",", "disp", ")", ";", "if", "(", "REGNO", "(", "x", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "return", "base_reg_disp", "(", "base_reg", "!=", "NULL", "?", "base_reg", ":", "x", ",", "disp", ")", ";", "rtx_insn", "*", "last_i", "=", "NULL", ";", "rtx", "last_set", "=", "NULL", ";", "for", "(", "df_ref", "d", "=", "DF_REG_DEF_CHAIN", "(", "REGNO", "(", "x", ")", ")", ";", "d", "!=", "NULL", ";", "d", "=", "DF_REF_NEXT_REG", "(", "d", ")", ")", "{", "rtx", "set", "=", "const_cast", "<", "rtx", ">", "(", "set_of", "(", "x", ",", "DF_REF_INSN", "(", "d", ")", ")", ")", ";", "if", "(", "last_set", "==", "NULL", "||", "rtx_equal_p", "(", "last_set", ",", "set", ")", ")", "{", "last_i", "=", "DF_REF_INSN", "(", "d", ")", ";", "last_set", "=", "set", ";", "}", "else", "{", "last_i", "=", "NULL", ";", "last_set", "=", "NULL", ";", "break", ";", "}", "}", "if", "(", "last_set", "!=", "NULL", "&&", "last_i", "!=", "NULL", ")", "return", "sh_find_base_reg_disp", "(", "last_i", ",", "XEXP", "(", "last_set", ",", "1", ")", ",", "disp", ",", "XEXP", "(", "last_set", ",", "0", ")", ")", ";", "return", "base_reg_disp", "(", "x", ",", "disp", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "base_reg_disp", "left_val", "=", "sh_find_base_reg_disp", "(", "insn", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "base_reg_disp", "right_val", "=", "sh_find_base_reg_disp", "(", "insn", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "if", "(", "left_val", ".", "is_reg", "(", ")", "&&", "right_val", ".", "is_disp", "(", ")", ")", "return", "base_reg_disp", "(", "left_val", ".", "reg", "(", ")", ",", "left_val", ".", "disp", "(", ")", "+", "right_val", ".", "disp", "(", ")", "+", "disp", ")", ";", "else", "if", "(", "right_val", ".", "is_reg", "(", ")", "&&", "left_val", ".", "is_disp", "(", ")", ")", "return", "base_reg_disp", "(", "right_val", ".", "reg", "(", ")", ",", "right_val", ".", "disp", "(", ")", "+", "left_val", ".", "disp", "(", ")", "+", "disp", ")", ";", "else", "return", "base_reg_disp", "(", "base_reg", ",", "disp", ")", ";", "}", "else", "if", "(", "CONST_INT_P", "(", "x", ")", ")", "return", "base_reg_disp", "(", "NULL", ",", "disp", "+", "INTVAL", "(", "x", ")", ")", ";", "return", "base_reg_disp", "(", "base_reg", ",", "disp", ")", ";", "}", "</s>" ]

[ "Find", "the", "base", "register", "and", "calculate", "the", "displacement", "for", "a", "given", "address", "rtx", "'", "x", "'", "." ]

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

[]

[ "<s>", "unsigned", "TPCInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TPC", "::", "SPILL_ARF_SAVE", ":", "case", "TPC", "::", "SPILL_DRF_SAVE", ":", "case", "TPC", "::", "SPILL_VRF_SAVE", ":", "case", "TPC", "::", "SPILL_VPRF_SAVE", ":", "case", "TPC", "::", "SPILL_IRF_SAVE", ":", "case", "TPC", "::", "SPILL_SRF_SAVE", ":", "case", "TPC", "::", "SPILL_ZRF_SAVE", ":", "case", "TPC", "::", "SPILL_SPRF_SAVE", ":", "FrameIndex", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "TPC::SPILL_ARF_SAVE", "TPC::SPILL_DRF_SAVE", "TPC::SPILL_VRF_SAVE", "TPC::SPILL_VPRF_SAVE", "TPC::SPILL_IRF_SAVE", "TPC::SPILL_SRF_SAVE", "TPC::SPILL_ZRF_SAVE", "TPC::SPILL_SPRF_SAVE", "0", "1", "0" ]

[]

[ "<s>", "bool", "MipsSEInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "switch", "(", "MI", "->", "getDesc", "(", ")", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Mips", "::", "RetRA", ":", "expandRetRA", "(", "MBB", ",", "MI", ")", ";", "break", ";", "case", "Mips", "::", "BuildPairF64", ":", "expandBuildPairF64", "(", "MBB", ",", "MI", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "ExtractElementF64", ":", "expandExtractElementF64", "(", "MBB", ",", "MI", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "MIPSeh_return32", ":", "case", "Mips", "::", "MIPSeh_return64", ":", "expandEhReturn", "(", "MBB", ",", "MI", ")", ";", "break", ";", "}", "MBB", ".", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::RetRA", "Mips::BuildPairF64", "Mips::ExtractElementF64", "Mips::MIPSeh_return32", "Mips::MIPSeh_return64" ]

[]

[ "<s>", "static", "bool", "read_vl_insn_p", "(", "rtx_insn", "*", "rinsn", ")", "{", "return", "recog_memoized", "(", "rinsn", ")", ">=", "0", "&&", "get_attr_type", "(", "rinsn", ")", "==", "TYPE_RDVL", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "is", "read", "vl", "instruction", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "void", "ARMConstantPoolValue", "::", "dump", "(", ")", "const", "{", "cerr", "<<", "\" \"", "<<", "*", "this", ";", "}", "</s>" ]

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

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

[]

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

[ "FUNCTION_VALUE_REGNO_P", "." ]

[ "mmix" ]

[]

[ "<s>", "static", "reg_class_t", "aarch64_ira_change_pseudo_allocno_class", "(", "int", "regno", ",", "reg_class_t", "allocno_class", ",", "reg_class_t", "best_class", ")", "{", "enum", "machine_mode", "mode", ";", "if", "(", "allocno_class", "!=", "ALL_REGS", ")", "return", "allocno_class", ";", "if", "(", "best_class", "!=", "ALL_REGS", ")", "return", "best_class", ";", "mode", "=", "PSEUDO_REGNO_MODE", "(", "regno", ")", ";", "return", "FLOAT_MODE_P", "(", "mode", ")", "||", "VECTOR_MODE_P", "(", "mode", ")", "?", "FP_REGS", ":", "GENERAL_REGS", ";", "}", "</s>" ]

[ "Implement", "TARGET_IRA_CHANGE_PSEUDO_ALLOCNO_CLASS", ".", "The", "register", "allocator", "chooses", "ALL_REGS", "if", "FP_REGS", "and", "GENERAL_REGS", "have", "the", "same", "cost", "even", "if", "ALL_REGS", "has", "a", "much", "larger", "cost", ".", "ALL_REGS", "is", "also", "used", "if", "the", "cost", "of", "both", "FP_REGS", "and", "GENERAL_REGS", "is", "lower", "than", "the", "memory", "cost", "(", "in", "this", "case", "the", "best", "class", "is", "the", "lowest", "cost", "one", ")", ".", "Using", "ALL_REGS", "irrespectively", "of", "its", "cost", "results", "in", "bad", "allocations", "with", "many", "redundant", "int", "<", "-", ">", "FP", "moves", "which", "are", "expensive", "on", "various", "cores", ".", "To", "avoid", "this", "we", "do", "n't", "allow", "ALL_REGS", "as", "the", "allocno", "class", ",", "but", "force", "a", "decision", "between", "FP_REGS", "and", "GENERAL_REGS", ".", "We", "use", "the", "allocno", "class", "if", "it", "is", "n't", "ALL_REGS", ".", "Similarly", ",", "use", "the", "best", "class", "if", "it", "is", "n't", "ALL_REGS", ".", "Otherwise", "set", "the", "allocno", "class", "depending", "on", "the", "mode", ".", "The", "result", "of", "this", "is", "that", "it", "is", "no", "longer", "inefficient", "to", "have", "a", "higher", "memory", "move", "cost", "than", "the", "register", "move", "cost", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "void", "set_ix86_tune_features", "(", "enum", "processor_type", "ix86_tune", ",", "bool", "dump", ")", "{", "unsigned", "int", "ix86_tune_mask", "=", "1u", "<<", "ix86_tune", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "X86_TUNE_LAST", ";", "++", "i", ")", "{", "if", "(", "ix86_tune_no_default", ")", "ix86_tune_features", "[", "i", "]", "=", "0", ";", "else", "ix86_tune_features", "[", "i", "]", "=", "!", "!", "(", "initial_ix86_tune_features", "[", "i", "]", "&", "ix86_tune_mask", ")", ";", "}", "if", "(", "dump", ")", "{", "fprintf", "(", "stderr", ",", "\"List of x86 specific tuning parameter names:\\n\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "X86_TUNE_LAST", ";", "i", "++", ")", "fprintf", "(", "stderr", ",", "\"%s : %s\\n\"", ",", "ix86_tune_feature_names", "[", "i", "]", ",", "ix86_tune_features", "[", "i", "]", "?", "\"on\"", ":", "\"off\"", ")", ";", "}", "parse_mtune_ctrl_str", "(", "dump", ")", ";", "}", "</s>" ]

[ "Helper", "function", "to", "set", "ix86_tune_features", ".", "IX86_TUNE", "is", "the", "processor", "type", "." ]

[ "i386", "1u", "0", "0", "\"List of x86 specific tuning parameter names:\\n\"", "0", "\"%s : %s\\n\"", "\"on\"", "\"off\"" ]

[]