Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "AssemblerPredicate", "<", "<STR_LIT>", ",", "<STR_LIT>", ">", ";" ]

[ "def", "HasFPARMv8", ":", "Predicate", "<", "<STR_LIT>", ">", "," ]

[ ";" ]

[ "}", "UUSetMap", "AssocMap", ";", "for", "(", "int", "x", "=", "DoubleRegs", ".", "find_first", "(", ")", ";", "x", ">=", "<NUM_LIT>", ";", "x", "=", "DoubleRegs", ".", "find_next", "(", "x", ")", ")", "{", "if", "(", "FixedRegs", "[", "x", "]", ")", "continue", ";", "unsigned", "R", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "x", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "PrintReg", "(", "R", ",", "TRI", ")", "<<", "<STR_LIT>", " ~~", "<STR_LIT>", ")", ";", "USet", "&", "Asc", "=", "AssocMap", "[", "R", "]", ";", "for", "(", "auto", "U", "=", "MRI", "->", "use_nodbg_begin", "(", "R", ")", ",", "Z", "=", "MRI", "->", "use_nodbg_end", "(", ")", ";", "U", "!=", "Z", ";", "++", "U", ")", "{", "MachineOperand", "&", "Op", "=", "*", "U", ";", "MachineInstr", "*", "UseI", "=", "Op", ".", "getParent", "(", ")", ";", "if", "(", "isFixedInstr", "(", "UseI", ")", ")", "continue", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "n", "=", "UseI", "->", "getNumOperands", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "UseI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "&", "MO", "==", "&", "Op", "||", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "getSubReg", "(", ")", ")", "continue", ";", "unsigned", "T", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "T", ")", ")", "{", "FixedRegs", ".", "set", "(", "x", ")", ";", "continue", ";", "}", "if", "(", "MRI", "->", "getRegClass", "(", "T", ")", "!=", "DoubleRC", ")", "continue", ";", "unsigned", "u", "=", "TargetRegisterInfo", "::", "virtReg2Index", "(", "T", ")", ";", "if", "(", "FixedRegs", "[", "u", "]", ")", "continue", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "'", "'", "<<", "PrintReg", "(", "T", ",", "TRI", ")", ")", ";", "Asc", ".", "insert", "(", "T", ")", ";", "AssocMap", "[", "T", "]", ".", "insert", "(", "R", ")", ";", "}", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "'", "\\n", "'", ")", ";", "}", "UUMap", "R2P", ";", "unsigned", "NextP", "=", "<NUM_LIT>", ";", "USet", "Visited", ";", "for", "(", "int", "x", "=", "DoubleRegs", ".", "find_first", "(", ")", ";", "x", ">=", "<NUM_LIT>", ";", "x", "=", "DoubleRegs", ".", "find_next", "(", "x", ")", ")", "{", "unsigned", "R", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "x", ")", ";", "if", "(", "Visited", ".", "count", "(", "R", ")", ")", "continue", ";", "unsigned", "ThisP", "=", "FixedRegs", "[", "x", "]", "?", "<NUM_LIT>", ":", "NextP", "++", ";", "UVect", "WorkQ", ";", "WorkQ", ".", "push_back", "(", "R", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "WorkQ", ".", "size", "(", ")", ";", "++", "i", ")", "{", "unsigned", "T", "=", "WorkQ", "[", "i", "]", ";", "if", "(", "Visited", ".", "count", "(", "T", ")", ")", "continue", ";", "R2P", "[", "T", "]", "=", "ThisP", ";", "Visited", ".", "insert", "(", "T", ")" ]

[ "}" ]

[ "if", "(", "distance", "<", "total", ")", "distance", "=", "-", "<NUM_LIT>", ";", "}", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "==", "CALL", ")", "call_dest", "=", "XEXP", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "else", "call_dest", "=", "XEXP", "(", "XEXP", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "call_decl", "=", "SYMBOL_REF_DECL", "(", "call_dest", ")", ";", "local_call", "=", "call_decl", "&&", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "call_decl", ")", ";", "if", "(", "!", "TARGET_LONG_CALLS", "&&", "(", "(", "TARGET_PA_20", "&&", "!", "sibcall", "&&", "distance", "<", "<NUM_LIT>", ")", "||", "distance", "<", "<NUM_LIT>", ")", ")", "length", "+=", "<NUM_LIT>", ";", "else", "if", "(", "TARGET_64BIT", "&&", "!", "local_call", ")", "length", "+=", "sibcall", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "else", "if", "(", "(", "TARGET_LONG_ABS_CALL", "||", "local_call", ")", "&&", "!", "flag_pic", ")", "length", "+=", "<NUM_LIT>", ";", "else", "if", "(", "(", "TARGET_SOM", "&&", "TARGET_LONG_PIC_SDIFF_CALL", ")", "||", "(", "TARGET_64BIT", "&&", "!", "TARGET_GAS", ")", "||", "(", "TARGET_GAS", "&&", "(", "TARGET_LONG_PIC_PCREL_CALL", "||", "local_call", ")", ")", ")", "{", "length", "+=", "<NUM_LIT>", ";", "if", "(", "!", "TARGET_PA_20", "&&", "!", "TARGET_NO_SPACE_REGS", ")", "length", "+=", "<NUM_LIT>", ";", "}", "else", "{", "length", "+=", "<NUM_LIT>", ";", "if", "(", "TARGET_SOM", ")", "length", "+=", "length_fp_args", "(", "insn", ")", ";", "if", "(", "flag_pic", ")", "length", "+=", "<NUM_LIT>", ";", "if", "(", "!", "TARGET_PA_20", ")", "{", "if", "(", "!", "sibcall", ")", "length", "+=", "<NUM_LIT>", ";", "if", "(", "!", "TARGET_NO_SPACE_REGS", ")", "length", "+=", "<NUM_LIT>", ";" ]

[ "const", "char", "*", "PTXTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown opcode", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "PTXISD::READ_PARAM", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "PTXISD::EXIT", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "PTXISD::RET", "<STR_LIT>", ";", "}", "}" ]

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

[ "<FIXS>", "if", "(", "CLScope", "==", "static_cast", "unsigned", ">", "(", "Scope", ")", ")", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "ScopeReg", "=", "buildConstantIntReg32", "(", "Scope", ",", "MIRBuilder", ",", "GR", ")", ";", "<FIXE>", "<FIXS>", "MIB", ".", "addUse", "(", "buildConstantIntReg32", "(", "MemScope", ",", "MIRBuilder", ",", "GR", ")", ")", ";", "<FIXE>" ]

[ "if", "(", "!", "(", "MemFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "||", "(", "Opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "Scope", "=", "MemScope", ";", "<BUGS>", "if", "(", "CLScope", "==", "static_cast", "unsigned", ">", "(", "Scope", ")", ")", "{", "<BUGE>", "ScopeReg", "=", "Call", "->", "Arguments", "[", "<NUM_LIT>", "]", ";", "<BUGS>", "MRI", "->", "setRegClass", "(", "ScopeReg", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "<BUGE>", "}", "if", "(", "!", "ScopeReg", ".", "isValid", "(", ")", ")", "<BUGS>", "ScopeReg", "=", "buildConstantIntReg", "(", "Scope", ",", "MIRBuilder", ",", "GR", ")", ";", "<BUGE>", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstr", "(", "Opcode", ")", ".", "addUse", "(", "ScopeReg", ")", ";", "if", "(", "Opcode", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "<BUGS>", "MIB", ".", "addUse", "(", "buildConstantIntReg", "(", "MemScope", ",", "MIRBuilder", ",", "GR", ")", ")", ";", "<BUGE>", "MIB", ".", "addUse", "(", "MemSemanticsReg", ")", ";", "return", "true", ";", "}" ]

[ "static", "std", "::", "pair", "<", "rtx_insn", "*", ",", "rtx_insn", "*", ">", "sh_try_split_insn_simple", "(", "rtx_insn", "*", "i", ",", "rtx_insn", "*", "curr_insn", ",", "int", "n", "=", "<NUM_LIT>", ")", "{", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "<STR_LIT>", "sh_try_split_insn_simple n = %d i = \\n", "<STR_LIT>", ",", "n", ")", ";", "print_rtl_single", "(", "dump_file", ",", "i", ")", ";", "fprintf", "(", "dump_file", ",", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "}", "rtx_insn", "*", "seq", "=", "safe_as_a", "<", "rtx_insn", "*", ">", "(", "split_insns", "(", "PATTERN", "(", "i", ")", ",", "curr_insn", ")", ")", ";", "if", "(", "seq", "==", "NULL", ")", "return", "std", "::", "make_pair", "(", "i", ",", "i", ")", ";", "for", "(", "rtx_insn", "*", "s", "=", "seq", ";", "s", "!=", "NULL", ";", "s", "=", "NEXT_INSN", "(", "s", ")", ")", "if", "(", "INSN_P", "(", "s", ")", "&&", "rtx_equal_p", "(", "PATTERN", "(", "s", ")", ",", "PATTERN", "(", "i", ")", ")", ")", "return", "std", "::", "make_pair", "(", "i", ",", "i", ")", ";", "unshare_all_rtl_in_chain", "(", "seq", ")", ";", "rtx_insn", "*", "seqlast", "=", "seq", ";", "while", "(", "NEXT_INSN", "(", "seqlast", ")", "!=", "NULL", ")", "seqlast", "=", "NEXT_INSN", "(", "seqlast", ")", ";", "if", "(", "rtx_insn", "*", "iprev", "=", "PREV_INSN", "(", "i", ")", ")", "SET_NEXT_INSN", "(", "iprev", ")", "=", "seq", ";", "if", "(", "rtx_insn", "*", "inext", "=", "NEXT_INSN", "(", "i", ")", ")", "SET_PREV_INSN", "(", "inext", ")", "=", "seqlast", ";", "SET_PREV_INSN", "(", "seq", ")", "=", "PREV_INSN", "(", "i", ")", ";", "SET_NEXT_INSN", "(", "seqlast", ")", "=", "NEXT_INSN", "(", "i", ")", ";", "SET_PREV_INSN", "(", "i", ")", "=", "NULL", ";", "SET_NEXT_INSN", "(", "i", ")", "=", "NULL", ";", "for", "(", "i", "=", "seq", ";", ";", "i", "=", "NEXT_INSN", "(", "i", ")", ")", "{", "std", "::", "pair", "<", "rtx_insn", "*", ",", "rtx_insn", "*", ">", "ii", "=", "sh_try_split_insn_simple", "(", "i", ",", "curr_insn", ",", "n", "+", "<NUM_LIT>", ")", ";", "if", "(", "i", "==", "seq", ")", "seq", "=", "ii", ".", "first", ";", "if", "(", "i", "==", "seqlast", ")", "{", "seqlast", "=", "ii", ".", "second", ";", "break", ";", "}", "i", "=", "ii", ".", "first", ";", "}", "return", "std", "::", "make_pair", "(", "seq", ",", "seqlast", ")", ";", "}" ]

[ "Given", "an", "rtx", "x", ",", "which", "is", "assumed", "to", "be", "some", "expression", "that", "has", "been", "matched", "by", "the", "'treg_set_expr", "'", "predicate", "before", ",", "split", "and", "emit", "the", "insns", "that", "are", "necessary", "to", "calculate", "the", "expression", "and", "store", "the", "result", "in", "the", "T", "bit", ".", "The", "splitting", "is", "done", "recursively", "similar", "to", "'try_split", "'", "in", "emit-rt.c", ".", "Unfortunately", "we", "ca", "n't", "use", "'try_split", "'", "here", "directly", ",", "as", "it", "tries", "to", "invoke", "'delete_insn", "'", "which", "then", "causes", "the", "DF", "parts", "to", "bail", "out", ",", "because", "we", "currently", "are", "inside", "another", "gen_split", "*", "function", "and", "would", "invoke", "'try_split", "'", "in", "a", "reentrant", "way", "." ]

[ ":", "VDQ_BHSI" ]

[ "(", "match_operand", ":", "VDQ_BHSI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VDQ_BHSI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "<", "max_opp", ">" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "Sched", "<", "[", "WriteVST4", "]", ">", ";" ]

[ "def", "VST4d16Pseudo_UPD", ":", "VSTQQWBPseudo", "<", "IIC_VST4u", ">", "," ]

[ ",", "DotExpr", ",", "OutContext", ")", ";" ]

[ "const", "GlobalValue", "*", "GV", "=", "cast", "<", "ARMConstantPoolConstant", ">", "(", "ACPV", ")", "->", "getGV", "(", ")", ";", "unsigned", "char", "TF", "=", "Subtarget", "->", "isTargetMachO", "(", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<NUM_LIT>", ";", "MCSym", "=", "GetARMGVSymbol", "(", "GV", ",", "TF", ")", ";", "}", "else", "if", "(", "ACPV", "->", "isMachineBasicBlock", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "cast", "<", "ARMConstantPoolMBB", ">", "(", "ACPV", ")", "->", "getMBB", "(", ")", ";", "MCSym", "=", "MBB", "->", "getSymbol", "(", ")", ";", "}", "else", "{", "assert", "(", "ACPV", "->", "isExtSymbol", "(", ")", "&&", "<STR_LIT>", "unrecognized constant pool value", "<STR_LIT>", ")", ";", "auto", "Sym", "=", "cast", "<", "ARMConstantPoolSymbol", ">", "(", "ACPV", ")", "->", "getSymbol", "(", ")", ";", "MCSym", "=", "GetExternalSymbolSymbol", "(", "Sym", ")", ";", "}", "const", "MCExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "MCSym", ",", "getModifierVariantKind", "(", "ACPV", "->", "getModifier", "(", ")", ")", ",", "OutContext", ")", ";", "if", "(", "ACPV", "->", "getPCAdjustment", "(", ")", ")", "{", "MCSymbol", "*", "PCLabel", "=", "getPICLabel", "(", "DL", ".", "getPrivateGlobalPrefix", "(", ")", ",", "getFunctionNumber", "(", ")", ",", "ACPV", "->", "getLabelId", "(", ")", ",", "OutContext", ")", ";", "const", "MCExpr", "*", "PCRelExpr", "=", "MCSymbolRefExpr", "::", "create", "(", "PCLabel", ",", "OutContext", ")", ";", "PCRelExpr", "=", "MCBinaryExpr", "::", "createAdd", "(", "PCRelExpr", ",", "MCConstantExpr", "::", "create", "(", "ACPV", "->", "getPCAdjustment", "(", ")", ",", "OutContext", ")", ",", "OutContext", ")", ";", "if", "(", "ACPV", "->", "mustAddCurrentAddress", "(", ")", ")", "{", "MCSymbol", "*", "DotSym", "=", "OutContext", ".", "createTempSymbol", "(", ")", ";", "OutStreamer", "->", "emitLabel", "(", "DotSym", ")", ";", "const", "MCExpr", "*", "DotExpr", "=", "MCSymbolRefExpr", "::", "create", "(", "DotSym", ",", "OutContext", ")", ";", "PCRelExpr", "=", "MCBinaryExpr", "::", "createSub", "(", "PCRelExpr" ]

[ "}" ]

[ "def", "pred_basic_u", ":", "VCMPPredicateOperand", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "pred_restricted_u_asmoperand", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "EncoderMethod", "=", "<STR_LIT>", ";" ]

[ "bool", "AArch64TargetLowering", "::", "shouldFoldConstantShiftPairToMask", "(", "const", "SDNode", "*", "N", ",", "CombineLevel", "Level", ")", "const", "{", "assert", "(", "(", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", "&&", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SRL", ")", "||", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SRL", "&&", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", ")", ")", "&&", "<STR_LIT>", "Expected shift-shift mask", "<STR_LIT>", ")", ";", "return", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "hasOneUse", "(", ")", ";", "}" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "fold", "a", "pair", "of", "shifts", "into", "a", "mask", "." ]

[ "LD1B_H", ",", "LD1B_S", ")", ">", ";" ]

[ "def", ":", "InstRW", "<", "[", "A64FXWrite_11Cyc_GI56", "]", ",", "(", "instrs", "LD1B", ",", "LD1B_D", "," ]

[ ")", ";" ]

[ "assert", "(", "!", "MF", ".", "getRegInfo", "(", ")", ".", "isLiveIn", "(", "ScratchReg", ")", "&&", "<STR_LIT>", "Scratch register is live-in", "<STR_LIT>", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "isVarArg", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "Segmented stacks do not support vararg functions.", "<STR_LIT>", ")", ";", "if", "(", "!", "STI", ".", "isTargetLinux", "(", ")", "&&", "!", "STI", ".", "isTargetDarwin", "(", ")", "&&", "!", "STI", ".", "isTargetWin32", "(", ")", "&&", "!", "STI", ".", "isTargetFreeBSD", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "Segmented stacks not supported on this platform.", "<STR_LIT>", ")", ";", "MachineBasicBlock", "*", "allocMBB", "=", "MF", ".", "CreateMachineBasicBlock", "(", ")", ";", "MachineBasicBlock", "*", "checkMBB", "=", "MF", ".", "CreateMachineBasicBlock", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "bool", "IsNested", "=", "false", ";", "if", "(", "Is64Bit", ")", "IsNested", "=", "HasNestArgument", "(", "&", "MF", ")", ";", "for", "(", "MachineBasicBlock", "::", "livein_iterator", "i", "=", "prologueMBB", ".", "livein_begin", "(", ")", ",", "e", "=", "prologueMBB", ".", "livein_end", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "allocMBB", "->", "addLiveIn", "(", "*", "i", ")", ";", "checkMBB", "->", "addLiveIn", "(", "*", "i", ")", ";", "}", "if", "(", "IsNested", ")", "allocMBB", "->", "addLiveIn", "(", "X86", "::", "R10", ")", ";", "MF", ".", "push_front", "(", "allocMBB", ")", ";", "MF", ".", "push_front", "(", "checkMBB", ")", ";", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "const", "Function", "*", "Fn", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "Fn", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "FixedStackSegment", ")", ")", "{", "StackSize", "=", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "FixedStackSegmentSize", ";", "}", "bool", "CompareStackPointer", "=", "StackSize", "<", "kSplitStackAvailable", ";", "if", "(", "Is64Bit", ")", "{", "if", "(", "STI", ".", "isTargetLinux", "(", ")", ")", "{", "TlsReg", "=", "X86", "::", "FS", ";", "TlsOffset", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", ")", "{", "TlsReg", "=", "X86", "::", "GS", ";", "TlsOffset", "=", "<NUM_LIT>", "+", "<NUM_LIT>", "*", "<NUM_LIT>", ";", "}", "else", "if", "(", "STI", ".", "isTargetFreeBSD", "(", ")", ")", "{", "TlsReg", "=", "X86", "::", "FS", ";", "TlsOffset", "=", "<NUM_LIT>", ";", "}", "else", "{", "report_fatal_error", "(", "<STR_LIT>", "Segmented stacks not supported on this platform.", "<STR_LIT>", ")", ";", "}", "if", "(", "CompareStackPointer", ")", "ScratchReg", "=", "X86", "::", "RSP", ";", "else", "BuildMI", "(", "checkMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "LEA64r", ")", ",", "ScratchReg", ")", ".", "addReg", "(", "X86", "::", "RSP", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "-", "StackSize", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "checkMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "CMP64rm", ")", ")", ".", "addReg", "(", "ScratchReg", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "TlsOffset", ")", ".", "addReg", "(", "TlsReg", ")", ";", "}", "else", "{", "if", "(", "STI", ".", "isTargetLinux", "(", ")", ")", "{", "TlsReg", "=", "X86", "::", "GS", ";", "TlsOffset", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", ")", "{", "TlsReg", "=", "X86", "::", "GS", ";", "TlsOffset", "=", "<NUM_LIT>", "+", "<NUM_LIT>", "*", "<NUM_LIT>", ";", "}", "else", "if", "(", "STI", ".", "isTargetWin32", "(", ")", ")", "{", "TlsReg", "=", "X86", "::", "FS", ";", "TlsOffset", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "STI", ".", "isTargetFreeBSD", "(", ")", ")", "{", "report_fatal_error", "(", "<STR_LIT>", "Segmented stacks not supported on FreeBSD i386.", "<STR_LIT>", ")", ";", "}", "else", "{", "report_fatal_error", "(", "<STR_LIT>", "Segmented stacks not supported on this platform.", "<STR_LIT>" ]

[ "(", ")", ";" ]

[ "return", "TargetTriple", ".", "isiOS" ]

[ ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";" ]

[ "return", "_", "_", "builtin_shuffle", "(", "_", "_", "a", ",", "_", "_", "b", ",", "(", "uint8x16_t", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";", "return", "_", "_", "builtin_shuffle", "(", "_", "_", "a", ",", "_", "_", "b", ",", "(", "uint8x16_t", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>" ]

[ "<FIXS>", "static", "machine_mode", "<FIXE>" ]

[ "#", "undef", "TARGET_ADDR_SPACE_ADDRESS_MODE", "#", "define", "TARGET_ADDR_SPACE_ADDRESS_MODE", "m32c_addr_space_address_mode", "<BUGS>", "static", "enum", "machine_mode", "<BUGE>", "m32c_addr_space_address_mode", "(", "addr_space_t", "addrspace", ")", "{", "switch", "(", "addrspace", ")" ]

[ "(", "const_string", "<STR_LIT>", ")", ")", ")" ]

[ "(", "const_string", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "]" ]

[ "<FIXS>", "MCSection", "*", "selectSmallSectionForGlobal", "(", "const", "GlobalObject", "*", "GO", ",", "<FIXE>" ]

[ "unsigned", "getSmallestAddressableSize", "(", "const", "Type", "*", "Ty", ",", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ")", "const", ";", "<BUGS>", "MCSection", "*", "selectSmallSectionForGlobal", "(", "const", "GlobalValue", "*", "GV", ",", "<BUGE>", "SectionKind", "Kind", ",", "const", "TargetMachine", "&", "TM", ")", "const", ";", "}", ";" ]

[ "<FIXS>", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "TuningFast7ByteNOP", "]", ")", "<FIXE>", "<FIXS>", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "TuningFast15ByteNOP", "]", ")", "<FIXE>", "<FIXS>", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "TuningFast11ByteNOP", "]", ")", "<FIXE>" ]

[ "return", "<NUM_LIT>", ";", "if", "(", "!", "STI", ".", "hasFeature", "(", "X86", "::", "FeatureNOPL", ")", "&&", "!", "STI", ".", "hasFeature", "(", "X86", "::", "Mode64Bit", ")", ")", "return", "<NUM_LIT>", ";", "<BUGS>", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "FeatureFast7ByteNOP", "]", ")", "<BUGE>", "return", "<NUM_LIT>", ";", "<BUGS>", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "FeatureFast15ByteNOP", "]", ")", "<BUGE>", "return", "<NUM_LIT>", ";", "<BUGS>", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "FeatureFast11ByteNOP", "]", ")", "<BUGE>", "return", "<NUM_LIT>", ";" ]

[ "_", "mmask16", ")", "_", "_", "U", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

[ "return", "(", "_", "_", "m512", ")", "_", "_", "builtin_ia32_maxps512_mask", "(", "(", "_", "_", "v16sf", ")", "_", "_", "A", ",", "(", "_", "_", "v16sf", ")", "_", "_", "B", ",", "(", "_", "_", "v16sf", ")", "_", "mm512_setzero_ps", "(", ")", ",", "(", "_" ]

[ "}" ]

[ "VT", "=", "VT", ".", "getScalarType", "(", ")", ";", "return", "VT", "==", "MVT", "::", "f32", "||", "VT", "==", "MVT", "::", "f64", "||", "VT", "==", "MVT", "::", "f16", ";" ]

[ "}" ]

[ "AU", ".", "addRequired", "<", "ReachingDefAnalysis", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";" ]

[ "unsigned", "ARMTargetLowering", "::", "getMaxSupportedInterleaveFactor", "(", ")", "const", "{", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "Subtarget", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "MVEMaxSupportedInterleaveFactor", ";", "return", "TargetLoweringBase", "::", "getMaxSupportedInterleaveFactor", "(", ")", ";", "}" ]

[ "Get", "the", "maximum", "supported", "factor", "for", "interleaved", "memory", "accesses", "." ]

[ "<FIXS>", "bool", "X86CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "ArrayRef", "Register", ">>", "VRegs", ")", "const", "{", "<FIXE>" ]

[ "}", "<BUGS>", "bool", "X86CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "Register", ">", "VRegs", ")", "const", "{", "<BUGE>", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";" ]

[ ",", "VTs", ",", "LO", ")", ";" ]

[ "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SRA", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "}", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "VT", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "uint64_t", "ShiftAmount", "=", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "SDValue", "Victim", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Invalid shift opcode", "<STR_LIT>", ")", ";", "case", "ISD", "::", "SRL", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SHL", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SRA", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "ROTL", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "ROTR", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "}", "if", "(", "VT", "==", "MVT", "::", "i16", ")", "{", "SDValue", "LO", ",", "HI", ",", "Flag", ";", "EVT", "HalfVT", "=", "VT", ".", "getHalfSizedIntegerVT", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "HalfVT", ",", "MVT", "::", "Glue", ")", ";", "LO", "=", "DAG", ".", "getTargetExtractSubreg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "HalfVT", ",", "Victim", ")", ";", "HI", "=", "DAG", ".", "getTargetExtractSubreg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "HalfVT", ",", "Victim", ")", ";", "while", "(", "ShiftAmount", "--", ")", "{", "if", "(", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "LO", "=", "DAG", ".", "getNode", "(", "Opc", ",", "dl" ]

[ "get", "(", "AMDGPU", "::", "S_BRANCH", ")", ")", ".", "addMBB", "(", "SplitBB", ")", ";" ]

[ "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Split block ", "<STR_LIT>", "<<", "printMBBReference", "(", "*", "BB", ")", "<<", "<STR_LIT>", " @ ", "<STR_LIT>", "<<", "*", "TermMI", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "MachineBasicBlock", "*", "SplitBB", "=", "BB", "->", "splitAt", "(", "*", "TermMI", ",", "true", ",", "LIS", ")", ";", "unsigned", "NewOpcode", "=", "<NUM_LIT>", ";", "switch", "(", "TermMI", "->", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "S_AND_B32", ":", "NewOpcode", "=", "AMDGPU", "::", "S_AND_B32_term", ";", "break", ";", "case", "AMDGPU", "::", "S_AND_B64", ":", "NewOpcode", "=", "AMDGPU", "::", "S_AND_B64_term", ";", "break", ";", "case", "AMDGPU", "::", "S_MOV_B32", ":", "NewOpcode", "=", "AMDGPU", "::", "S_MOV_B32_term", ";", "break", ";", "case", "AMDGPU", "::", "S_MOV_B64", ":", "NewOpcode", "=", "AMDGPU", "::", "S_MOV_B64_term", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "NewOpcode", ")", "TermMI", "->", "setDesc", "(", "TII", "->", "get", "(", "NewOpcode", ")", ")", ";", "if", "(", "SplitBB", "!=", "BB", ")", "{", "using", "DomTreeT", "=", "DomTreeBase", "<", "MachineBasicBlock", ">", ";", "SmallVector", "<", "DomTreeT", "::", "UpdateType", ",", "<NUM_LIT>", ">", "DTUpdates", ";", "for", "(", "MachineBasicBlock", "*", "Succ", ":", "SplitBB", "->", "successors", "(", ")", ")", "{", "DTUpdates", ".", "push_back", "(", "{", "DomTreeT", "::", "Insert", ",", "SplitBB", ",", "Succ", "}", ")", ";", "DTUpdates", ".", "push_back", "(", "{", "DomTreeT", "::", "Delete", ",", "BB", ",", "Succ", "}", ")", ";", "}", "DTUpdates", ".", "push_back", "(", "{", "DomTreeT", "::", "Insert", ",", "BB", ",", "SplitBB", "}", ")", ";", "if", "(", "MDT", ")", "MDT", "->", "getBase", "(", ")", ".", "applyUpdates", "(", "DTUpdates", ")", ";", "if", "(", "PDT", ")", "PDT", "->", "getBase", "(", ")", ".", "applyUpdates", "(", "DTUpdates", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "*", "BB", ",", "BB", "->", "end", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->" ]

[ "dw2_asm_output_data", "(", "<NUM_LIT>", ",", "core_relo_off", ",", "<STR_LIT>", "core_relo_offset", "<STR_LIT>", ")", ";" ]

[ "uint32_t", "line_info_off", "=", "<NUM_LIT>", ",", "line_info_len", "=", "<NUM_LIT>", ";", "uint32_t", "core_relo_off", "=", "<NUM_LIT>", ",", "core_relo_len", "=", "<NUM_LIT>", ";", "size_t", "i", ";", "bpf_core_section_ref", "sec", ";", "core_relo_len", "+=", "vec_safe_length", "(", "bpf_core_sections", ")", "*", "sizeof", "(", "struct", "btf_ext_section_header", ")", ";", "FOR_EACH_VEC_ELT", "(", "*", "bpf_core_sections", ",", "i", ",", "sec", ")", "core_relo_len", "+=", "vec_safe_length", "(", "sec", "->", "relocs", ")", "*", "sizeof", "(", "struct", "btf_ext_reloc", ")", ";", "if", "(", "core_relo_len", ")", "core_relo_len", "+=", "sizeof", "(", "uint32_t", ")", ";", "dw2_asm_output_data", "(", "<NUM_LIT>", ",", "func_info_off", ",", "<STR_LIT>", "func_info_offset", "<STR_LIT>", ")", ";", "dw2_asm_output_data", "(", "<NUM_LIT>", ",", "func_info_len", ",", "<STR_LIT>", "func_info_len", "<STR_LIT>", ")", ";", "dw2_asm_output_data", "(", "<NUM_LIT>", ",", "line_info_off", ",", "<STR_LIT>", "line_info_offset", "<STR_LIT>", ")", ";", "dw2_asm_output_data", "(", "<NUM_LIT>", ",", "line_info_len", ",", "<STR_LIT>", "line_info_len", "<STR_LIT>", ")", ";" ]

[ "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "Result", ";" ]

[ "if", "(", "SDValue", "Rotate", "=", "lowerVectorShuffleAsByteRotate", "(", "DL", ",", "MVT", "::", "v32i8", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "Rotate", ";", "if", "(", "SDValue", "V", "=", "lowerShuffleAsRepeatedMaskAndLanePermute", "(", "DL", ",", "MVT", "::", "v32i8", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "V", ";", "if", "(", "V2", ".", "isUndef", "(", ")", "&&", "is128BitLaneCrossingShuffleMask", "(", "MVT", "::", "v32i8", ",", "Mask", ")", ")", "return", "lowerVectorShuffleAsLanePermuteAndBlend", "(", "DL", ",", "MVT", "::", "v32i8", ",", "V1", ",", "V2", ",", "Mask", ",", "DAG", ")", ";", "if", "(", "SDValue", "PSHUFB", "=", "lowerVectorShuffleWithPSHUFB", "(", "DL", ",", "MVT", "::", "v32i8", ",", "Mask", ",", "V1", ",", "V2", ",", "Subtarget", ",", "DAG", ")", ")", "return", "PSHUFB", ";", "if", "(", "SDValue", "Result", "=", "lowerVectorShuffleByMerging128BitLanes", "(", "DL", ",", "MVT", "::", "v32i8", ",", "V1", "," ]

[ "<STR_LIT>", ")" ]

[ "(", "define_cpu_unit", "<STR_LIT>" ]

[ "int", "SparcSubtarget", "::", "getAdjustedFrameSize", "(", "int", "frameSize", ")", "const", "{", "if", "(", "is64Bit", "(", ")", ")", "{", "frameSize", "+=", "<NUM_LIT>", ";", "frameSize", "=", "RoundUpToAlignment", "(", "frameSize", ",", "<NUM_LIT>", ")", ";", "}", "else", "{", "frameSize", "+=", "<NUM_LIT>", ";", "frameSize", "=", "RoundUpToAlignment", "(", "frameSize", ",", "<NUM_LIT>", ")", ";", "}", "return", "frameSize", ";", "}" ]

[ "Given", "a", "actual", "stack", "size", "as", "determined", "by", "FrameInfo", ",", "this", "function", "returns", "adjusted", "framesize", "which", "includes", "space", "for", "RSA", ",", "return", "address", ",", "and", "frame", "poitner", "." ]

[ "<STR_LIT>" ]

[ "(", "match_operand", ":", "V2DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", "]", "UNSPEC_UNSIGNED_FIX_NOTRUNC", ")", ")", "]", "<STR_LIT>" ]

[ "uint64_t", "enc", "=", "<NUM_LIT>", "-", "N", "-", ">", "getZExtValue", "(", ")", ";" ]

[ "return", "CurDAG", "-", ">", "getTargetConstant", "(", "enc", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i64", ")", ";", "}", "]", ">", ";", "def", "i32shift_sext_i8", ":", "Operand", "<", "i64", ">", ",", "SDNodeXForm", "<", "imm", ",", "[", "{", "uint64_t", "enc", "=", "<NUM_LIT>", "-", "N", "-", ">", "getZExtValue", "(", ")", ";", "enc", "=", "enc", ">", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "enc", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "enc", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i64", ")", ";", "}", "]", ">", ";", "def", "i32shift_sext_i16", ":", "Operand", "<", "i64", ">", ",", "SDNodeXForm", "<", "imm", ",", "[", "{", "uint64_t", "enc", "=", "<NUM_LIT>", "-", "N", "-", ">", "getZExtValue", "(", ")", ";", "enc", "=", "enc", ">", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "enc", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "enc", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i64", ")", ";", "}", "]", ">", ";", "def", "i64shift_a", ":", "Operand", "<", "i64", ">", ",", "SDNodeXForm", "<", "imm", ",", "[", "{", "uint64_t", "enc", "=", "(", "<NUM_LIT>", "-", "N", "-", ">", "getZExtValue", "(", ")", ")", "&", "<NUM_LIT>", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "enc", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i64", ")", ";", "}", "]", ">", ";", "def", "i64shift_b", ":", "Operand", "<", "i64", ">", ",", "SDNodeXForm", "<", "imm", ",", "[", "{", "uint64_t", "enc", "=", "<NUM_LIT>", "-", "N", "-", ">", "getZExtValue", "(", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "enc", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i64", ")", ";", "}", "]", ">", ";", "def", "i64shift_sext_i8", ":", "Operand", "<", "i64", ">", ",", "SDNodeXForm", "<", "imm", ",", "[", "{" ]

[ "next", ";" ]

[ "int", "align_log", "=", "floor_log2", "(", "GET_MODE_SIZE", "(", "c", "->", "mode", ")", ")", ";", "insn", "=", "emit_insn_after", "(", "gen_align", "(", "GEN_INT", "(", "align_log", ")", ")", ",", "insn", ")", ";", "}", "align", "=", "GET_MODE_SIZE", "(", "c", "->", "mode", ")", ";", "insn", "=", "emit_label_after", "(", "c", "->", "label", ",", "insn", ")", ";", "insn", "=", "mips16_emit_constants_1", "(", "c", "->", "mode", ",", "c", "->", "value", ",", "insn", ")", ";", "next", "=", "c", "->" ]

[ ")", ")", "]" ]

[ "[", "(", "set", "(", "reg", ":", "CC", "CR6_REGNO", ")", "(", "unspec", ":", "CC", "[", "(", "eq", ":", "CC", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>" ]

[ "_", "A", ")", ";" ]

[ "return", "_", "_", "builtin_arm_waccb", "(", "(", "_", "_", "v8qi", ")", "_" ]

[ "reloc_arm_jt_base", ")", ";" ]

[ "Binary", "|=", "getMachineOpValue", "(", "MI", ",", "<NUM_LIT>", ")", "<<", "<STR_LIT>", "::", "<STR_LIT>", ";", "Binary", "|=", "ARMRegisterInfo", "::", "getRegisterNumbering", "(", "ARM", "::", "PC", ")", "<<", "<STR_LIT>", "::", "<STR_LIT>", ";", "Binary", "|=", "<NUM_LIT>", "<<", "<STR_LIT>", "::", "<STR_LIT>", ";", "emitJumpTableAddress", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ",", "ARM", "::" ]

[ "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}" ]

[ ",", "const0_rtx", ")", ";" ]

[ "emit_insn", "(", "ix86_gen_add3", "(", "out", ",", "out", ",", "const1_rtx", ")", ")", ";", "emit_label", "(", "align_3_label", ")", ";", "}", "emit_cmp_and_jump_insns", "(", "mem", ",", "const0_rtx", ",", "EQ", ",", "NULL", ",", "QImode", ",", "<NUM_LIT>", ",", "end_0_label", ")", ";", "emit_insn", "(", "ix86_gen_add3", "(", "out", ",", "out", ",", "const1_rtx", ")", ")", ";", "}", "emit_label", "(", "align_4_label", ")", ";", "mem", "=", "change_address", "(", "src", ",", "SImode", ",", "out", ")", ";", "emit_move_insn", "(", "scratch", ",", "mem", ")", ";", "emit_insn", "(", "ix86_gen_add3", "(", "out", ",", "out", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "tmpreg", ",", "scratch", ",", "GEN_INT", "(", "-", "<NUM_LIT>", ")", ")", ")", ";", "emit_insn", "(", "gen_one_cmplsi2", "(", "scratch", ",", "scratch", ")", ")", ";", "emit_insn", "(", "gen_andsi3", "(", "tmpreg", ",", "tmpreg", ",", "scratch", ")", ")", ";", "emit_insn", "(", "gen_andsi3", "(", "tmpreg", ",", "tmpreg", ",", "gen_int_mode", "(", "<NUM_LIT>", ",", "SImode", ")", ")", ")", ";", "emit_cmp_and_jump_insns", "(", "tmpreg", ",", "const0_rtx", ",", "EQ", ",", "<NUM_LIT>", ",", "SImode", ",", "<NUM_LIT>", ",", "align_4_label", ")", ";", "if", "(", "TARGET_CMOVE", ")", "{", "rtx", "reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "reg2", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "reg", ",", "tmpreg", ")", ";", "emit_insn", "(", "gen_lshrsi3", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "emit_insn", "(", "gen_testsi_ccno_1", "(", "tmpreg", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "tmp", "=", "gen_rtx_REG", "(", "CCNOmode", ",", "FLAGS_REG", ")", ";", "tmp", "=", "gen_rtx_EQ", "(", "VOIDmode", ",", "tmp", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "tmpreg", ",", "gen_rtx_IF_THEN_ELSE", "(", "SImode", ",", "tmp", ",", "reg", ",", "tmpreg", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "SImode", ",", "reg2", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "out", ",", "const2_rtx", ")", ")", ")", ";", "tmp", "=", "gen_rtx_REG", "(", "CCNOmode", ",", "FLAGS_REG", ")", ";", "tmp", "=", "gen_rtx_EQ", "(", "VOIDmode", ",", "tmp", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "out", ",", "gen_rtx_IF_THEN_ELSE", "(", "Pmode", ",", "tmp", ",", "reg2", ",", "out", ")", ")", ")", ";", "}", "else", "{", "rtx_code_label", "*", "end_2_label", "=", "gen_label_rtx", "(", ")", ";", "emit_insn", "(", "gen_testsi_ccno_1", "(", "tmpreg", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "tmp", "=", "gen_rtx_REG", "(", "CCNOmode", ",", "FLAGS_REG", ")", ";", "tmp", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "tmp" ]

[ "}" ]

[ "default", ":", "break", ";", "}", "return", "std", "::", "pair", "(", "nullptr", ",", "-", "<NUM_LIT>", ")", ";", "}", "Value", "*", "Ptr", ";", "if", "(", "match", "(", "const_cast", "<", "Value", "*", ">", "(", "V", ")", ",", "m_c_And", "(", "m_Not", "(", "m_Intrinsic", "<", "Intrinsic", "::", "amdgcn_is_shared", ">", "(", "m_Value", "(", "Ptr", ")", ")", ")", ",", "m_Not", "(", "m_Intrinsic", "<", "Intrinsic", "::", "amdgcn_is_private", ">", "(", "m_Deferred", "(", "Ptr", ")", ")", ")", ")", ")", ")", "return", "std", "::", "pair", "(", "Ptr", ",", "AMDGPUAS", "::", "GLOBAL_ADDRESS", ")", ";", "return", "std", "::", "pair", "(", "nullptr", ",", "-", "<NUM_LIT>", ")", ";" ]

[ "let", "Itinerary", "=", "IIC_VectorOp", ";" ]

[ "let", "OutOperandList", "=", "(", "outs", ")", ";", "let", "InOperandList", "=", "(", "ins", "VRF", ":", "$", "op1", ",", "VRF", ":", "$", "op2", ",", "VRF", ":", "$", "op3", ",", "VRF", ":", "$", "op4", ",", "VRF", ":", "$", "op5", ",", "VRF", ":", "$", "op6", ",", "VRF", ":", "$", "op7", ",", "VRF", ":", "$", "op8", ",", "VRF", ":", "$", "op9", ",", "VRF", ":", "$", "op10", ",", "VRF", ":", "$", "op11", ",", "VRF", ":", "$", "op12", ",", "VRF", ":", "$", "op13", ",", "VRF", ":", "$", "op14", ",", "VRF", ":", "$", "op15", ",", "VRF", ":", "$", "op16", ",", "VRF", ":", "$", "op17", ",", "VRF", ":", "$", "op18", ",", "VRF", ":", "$", "op19", ",", "VRF", ":", "$", "op20", ")", ";", "let", "Pattern", "=", "pattern", ";" ]

[ "static", "void", "moxie_asm_trampoline_template", "(", "FILE", "*", "f", ")", "{", "fprintf", "(", "f", ",", "<STR_LIT>", "\\tpush $sp, $r0\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "f", ",", "<STR_LIT>", "\\tldi.l $r0, 0x0\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "f", ",", "<STR_LIT>", "\\tsto.l 0x8($fp), $r0\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "f", ",", "<STR_LIT>", "\\tpop $sp, $r0\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "f", ",", "<STR_LIT>", "\\tjmpa 0x0\\n", "<STR_LIT>", ")", ";", "}" ]

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

[ "rtx", "src", "=", "operands", "[", "<NUM_LIT>", "]" ]

[ "(", "unsigned_float", ":", "SFDF", "(", "unsigned_fix", ":", "SI", "(", "match_operand", ":", "SFDF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "pc", ")", "]", "{", "rtx", "dest", "=", "operands", "[", "<NUM_LIT>", "]" ]

[ ")" ]

[ "(", "define_cpu_unit", "<STR_LIT>", "<STR_LIT>" ]

[ "=", "<NUM_LIT>", ";" ]

[ "def", "VLLDM", ":", "AXSI4", "<", "(", "outs", ")", ",", "(", "ins", "GPRnopc", ":", "$", "Rn", ",", "pred", ":", "$", "p", ")", ",", "IndexModeNone", ",", "NoItinerary", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Requires", "<", "[", "HasV8MMainline", ",", "Has8MSecExt", "]", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "mayLoad" ]

[ "<FIXS>", "asm_fprintf", "(", "file", ",", "<STR_LIT>", "\\t{liu|lis} %s,0x%x\\n\\t{oril|ori} %s,%s,%d\\n", "<STR_LIT>", ",", "<FIXE>" ]

[ "{", "int", "neg_size", "=", "info", "->", "main_save_offset", "-", "info", "->", "total_size", ";", "loc", "=", "<NUM_LIT>", ";", "<BUGS>", "asm_fprintf", "(", "file", ",", "<STR_LIT>", "\\t{liu|lis} %s,%d\\n\\t{oril|ori} %s,%s,%d\\n", "<STR_LIT>", ",", "<BUGE>", "reg_names", "[", "<NUM_LIT>", "]", ",", "(", "neg_size", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ",", "reg_names", "[", "<NUM_LIT>", "]", ",", "neg_size", "&", "<NUM_LIT>", ")", ";" ]

[ "<FIXS>", "<STR_LIT>", "<FIXE>" ]

[ "[", "(", "set", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "float_truncate", ":", "DF", "(", "match_operand", ":", "IEEE128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "<FIXS>", "O", "<<", "Mang", "->", "getMangledName", "(", "MO", ".", "getGlobal", "(", ")", ")", ";", "<FIXE>" ]

[ "printBasicBlockLabel", "(", "MO", ".", "getMBB", "(", ")", ")", ";", "return", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "<BUGS>", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "O", "<<", "Mang", "->", "getValueName", "(", "GV", ")", ";", "}", "<BUGE>", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "O", "<<", "MO", ".", "getSymbolName", "(", ")", ";" ]

[ "}", "else", "{" ]

[ "const", "M680x0FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "MachineOperand", "&", "Disp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", "-", "<NUM_LIT>", ")", ";", "MachineOperand", "&", "Base", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "int", "Imm", "=", "(", "int", ")", "(", "Disp", ".", "getImm", "(", ")", ")", ";", "int", "FIndex", "=", "(", "int", ")", "(", "Base", ".", "getIndex", "(", ")", ")", ";", "bool", "AfterFPPop", "=", "false", ";", "unsigned", "BasePtr", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "BasePtr", "=", "(", "FIndex", "<", "<NUM_LIT>", "?", "FramePtr", ":", "getBaseRegister", "(", ")", ")", ";", "else", "if", "(", "needsStackRealignment", "(", "MF", ")", ")", "BasePtr", "=", "(", "FIndex", "<", "<NUM_LIT>", "?", "FramePtr", ":", "StackPtr", ")", ";", "else", "if", "(", "AfterFPPop", ")", "BasePtr", "=", "StackPtr", ";", "else", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ")", ";", "Base", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "int", "FIOffset", ";", "unsigned", "IgnoredFrameReg", ";", "if", "(", "AfterFPPop", ")", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "FIOffset", "=", "MFI", ".", "getObjectOffset", "(", "FIndex", ")", "-", "TFI", "->", "getOffsetOfLocalArea", "(", ")", ";" ]

[ "ProcessBlock", "(", "MBB", ")", ";" ]

[ "Scopes", ".", "push_back", "(", "Node", ")", ";", "const", "std", "::", "vector", "<", "MachineDomTreeNode", "*", ">", "&", "Children", "=", "Node", "->", "getChildren", "(", ")", ";", "OpenChildren", "[", "Node", "]", "=", "Children", ".", "size", "(", ")", ";", "for", "(", "MachineDomTreeNode", "*", "Child", ":", "Children", ")", "WorkList", ".", "push_back", "(", "Child", ")", ";", "}", "while", "(", "!", "WorkList", ".", "empty", "(", ")", ")", ";", "for", "(", "MachineDomTreeNode", "*", "Node", ":", "Scopes", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "Node", "->", "getBlock", "(", ")", ";", "EnterScope", "(", "MBB", ")", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qm", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Qd", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qd", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Qm", "{", "<NUM_LIT>", "}", ";" ]

[ "<STR_LIT>", ")", ")" ]

[ "(", "if_then_else", "(", "ior", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>" ]

[ "x_flag_shrink_wrap", ";" ]

[ "warning", "(", "<NUM_LIT>", ",", "<STR_LIT>", "target CPU does not support THUMB instructions", "<STR_LIT>", ")", ";", "opts", "->", "x_target_flags", "&=", "~", "MASK_THUMB", ";", "}", "if", "(", "TARGET_APCS_FRAME", "&&", "TARGET_THUMB_P", "(", "opts", "->", "x_target_flags", ")", ")", "{", "opts", "->", "x_target_flags", "&=", "~", "MASK_APCS_FRAME", ";", "}", "if", "(", "TARGET_THUMB_P", "(", "opts", "->", "x_target_flags", ")", "&&", "TARGET_CALLEE_INTERWORKING", ")", "opts", "->", "x_target_flags", "|=", "MASK_INTERWORK", ";", "cl_optimization", "*", "to", "=", "TREE_OPTIMIZATION", "(", "init_optimize", ")", ";", "if", "(", "!", "opts_set", "->", "x_arm_restrict_it", ")", "opts", "->", "x_arm_restrict_it", "=", "arm_arch8", ";", "if", "(", "!", "TARGET_THUMB2_P", "(", "opts", "->", "x_target_flags", ")", "||", "!", "arm_arch_notm", ")", "opts", "->", "x_arm_restrict_it", "=", "<NUM_LIT>", ";", "if", "(", "!", "opts_set", "->", "x_unaligned_access", ")", "{", "opts", "->", "x_unaligned_access", "=", "(", "TARGET_32BIT_P", "(", "opts", "->", "x_target_flags", ")", "&&", "arm_arch6", "&&", "(", "arm_arch_notm", "||", "arm_arch7", ")", ")", ";", "}", "else", "if", "(", "opts", "->", "x_unaligned_access", "==", "<NUM_LIT>", "&&", "!", "(", "arm_arch6", "&&", "(", "arm_arch_notm", "||", "arm_arch7", ")", ")", ")", "{", "warning", "(", "<NUM_LIT>", ",", "<STR_LIT>", "target CPU does not support unaligned accesses", "<STR_LIT>", ")", ";", "opts", "->", "x_unaligned_access", "=", "<NUM_LIT>", ";", "}", "if", "(", "TARGET_THUMB1_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_flag_schedule_insns", "=", "<NUM_LIT>", ";", "else", "opts", "->", "x_flag_schedule_insns", "=", "to", "->", "x_flag_schedule_insns", ";", "if", "(", "optimize_function_for_size_p", "(", "cfun", ")", "&&", "TARGET_THUMB2_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_flag_shrink_wrap", "=", "false", ";", "else", "opts", "->", "x_flag_shrink_wrap", "=", "to", "->" ]

[ "B", ")", ";" ]

[ "static", "const", "_", "_", "vector", "unsigned", "int", "float_exp_mask", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "static", "const", "_", "_", "vector", "unsigned", "int", "mask", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "a", "=", "(", "_", "_", "vector", "unsigned", "int", ")", "vec_abs", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ")", ";", "b", "=", "(", "_", "_", "vector", "unsigned", "int", ")", "vec_abs", "(", "(", "_", "_", "v4sf", ")", "_", "_" ]

[ "if", "(", "SM_SentinelUndef", "==", "M", "||", "!", "DemandedElts", "[", "i", "]", ")", "continue", ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "SDValue", "Vec", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "auto", "*", "CIdx", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "MVT", "VecVT", "=", "Vec", ".", "getSimpleValueType", "(", ")", ";", "if", "(", "CIdx", "&&", "CIdx", "->", "getAPIntValue", "(", ")", ".", "ult", "(", "VecVT", ".", "getVectorNumElements", "(", ")", ")", "&&", "!", "DemandedElts", "[", "CIdx", "->", "getZExtValue", "(", ")", "]", ")", "return", "Vec", ";", "break", ";", "}", "}", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "ShuffleMask", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "ShuffleOps", ";", "if", "(", "getTargetShuffleInputs", "(", "Op", ",", "ShuffleOps", ",", "ShuffleMask", ",", "DAG", ",", "Depth", ")", ")", "{", "int", "NumOps", "=", "ShuffleOps", ".", "size", "(", ")", ";", "if", "(", "ShuffleMask", ".", "size", "(", ")", "==", "(", "unsigned", ")", "NumElts", "&&", "llvm", "::", "all_of", "(", "ShuffleOps", ",", "[", "VT", "]", "(", "SDValue", "V", ")", "{", "return", "VT", ".", "getSizeInBits", "(", ")", "==", "V", ".", "getValueSizeInBits", "(", ")", ";", "}", ")", ")", "{", "APInt", "IdentityOp", "=", "APInt", "::", "getAllOnesValue", "(", "NumOps", ")", ";", "bool", "AllUndef", "=", "true", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElts", ";", "++", "i", ")", "{", "int", "M", "=", "ShuffleMask", "[", "i", "]", ";" ]

[ "<NUM_LIT>", "}", "=", "funct", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "rt", ";", "bits", "<", "<NUM_LIT>", ">", "imm10", ";", "bits", "<", "<NUM_LIT>", ">", "Inst", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "rs", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "rt", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm10", ";", "let", "Inst", "{", "<NUM_LIT>", "-" ]

[ "<FIXS>", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", "<FIXE>" ]

[ "(", "and", "(", "ge", "(", "minus", "(", "match_dup", "<NUM_LIT>", ")", "(", "pc", ")", ")", "(", "const_int", "-", "<NUM_LIT>", ")", ")", "(", "le", "(", "minus", "(", "match_dup", "<NUM_LIT>", ")", "(", "pc", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "const_int", "<NUM_LIT>", ")", "<BUGS>", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "]", "<BUGE>", ")", "(", "define_insn", "<STR_LIT>" ]

[ "&", ")", "const", "{" ]

[ "virtual", "gimple", "*", "fold", "(", "gimple_folder" ]

[ "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "unsigned", "SrcIdx", "=", "~", "<NUM_LIT>", ";", "if", "(", "OpNo", "==", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ")", "{", "<FIXE>", "<FIXS>", "SrcIdx", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "OpNo", "==", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ")", "{", "<FIXE>", "<FIXS>", "SrcIdx", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "OpNo", "==", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src2", ")", ")", "{", "<FIXE>", "<FIXS>", "unsigned", "ModVal", "=", "Mod", ".", "getImm", "(", ")", ";", "uint16_t", "ImmLo", "=", "static_cast", "uint16_t", ">", "(", "Fold", ".", "ImmToFold", ">>", "(", "ModVal", "&", "<STR_LIT>", "::", "<STR_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", ";", "uint16_t", "ImmHi", "=", "static_cast", "uint16_t", ">", "(", "Fold", ".", "ImmToFold", ">>", "(", "ModVal", "&", "<STR_LIT>", "::", "<STR_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", ";", "uint32_t", "Imm", "=", "(", "static_cast", "uint32_t", ">", "(", "ImmHi", ")", "<<", "<NUM_LIT>", ")", "|", "ImmLo", ";", "unsigned", "NewModVal", "=", "ModVal", "&", "~", "(", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "auto", "tryFoldToInline", "=", "[", "&", "]", "(", "uint32_t", "Imm", ")", "->", "bool", "{", "if", "(", "AMDGPU", "::", "isInlinableLiteralV216", "(", "Imm", ",", "OpType", ")", ")", "{", "Mod", ".", "setImm", "(", "NewModVal", "|", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Old", ".", "ChangeToImmediate", "(", "Imm", ")", ";", "return", "true", ";", "}", "uint16_t", "Lo", "=", "static_cast", "uint16_t", ">", "(", "Imm", ")", ";", "uint16_t", "Hi", "=", "static_cast", "uint16_t", ">", "(", "Imm", ">>", "<NUM_LIT>", ")", ";", "if", "(", "Lo", "==", "Hi", ")", "{", "if", "(", "AMDGPU", "::", "isInlinableLiteralV216", "(", "Lo", ",", "OpType", ")", ")", "{", "Mod", ".", "setImm", "(", "NewModVal", ")", ";", "Old", ".", "ChangeToImmediate", "(", "Lo", ")", ";", "return", "true", ";", "}", "if", "(", "static_cast", "int16_t", ">", "(", "Lo", ")", "<NUM_LIT>", ")", "{", "int32_t", "SExt", "=", "static_cast", "int16_t", ">", "(", "Lo", ")", ";", "if", "(", "AMDGPU", "::", "isInlinableLiteralV216", "(", "SExt", ",", "OpType", ")", ")", "{", "Mod", ".", "setImm", "(", "NewModVal", ")", ";", "Old", ".", "ChangeToImmediate", "(", "SExt", ")", ";", "return", "true", ";", "}", "}", "if", "(", "OpType", "==", "AMDGPU", "::", "OPERAND_REG_IMM_V2INT16", "||", "OpType", "==", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_V2INT16", ")", "{", "if", "(", "AMDGPU", "::", "isInlinableLiteralV216", "(", "Lo", "<<", "<NUM_LIT>", ",", "OpType", ")", ")", "{", "Mod", ".", "setImm", "(", "NewModVal", "|", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Old", ".", "ChangeToImmediate", "(", "static_cast", "uint32_t", ">", "(", "Lo", ")", "<<", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "}", "}", "else", "{", "uint32_t", "Swapped", "=", "(", "static_cast", "uint32_t", ">", "(", "Lo", ")", "<<", "<NUM_LIT>", ")", "|", "Hi", ";", "if", "(", "AMDGPU", "::", "isInlinableLiteralV216", "(", "Swapped", ",", "OpType", ")", ")", "{", "Mod", ".", "setImm", "(", "NewModVal", "|", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Old", ".", "ChangeToImmediate", "(", "Swapped", ")", ";", "return", "true", ";", "}", "}", "<FIXE>", "<FIXS>", "if", "(", "tryFoldToInline", "(", "Imm", ")", ")", "<FIXE>", "<FIXS>", "return", "false", ";", "<FIXE>" ]

[ "MachineOperand", "&", "Old", "=", "MI", "->", "getOperand", "(", "Fold", ".", "UseOpNo", ")", ";", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "int", "OpNo", "=", "MI", "->", "getOperandNo", "(", "&", "Old", ")", ";", "<BUGS>", "<BUGE>", "int", "ModIdx", "=", "-", "<NUM_LIT>", ";", "<BUGS>", "if", "(", "OpNo", "==", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ")", "<BUGE>", "ModIdx", "=", "AMDGPU", "::", "OpName", "::", "src0_modifiers", ";", "<BUGS>", "else", "if", "(", "OpNo", "==", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ")", "<BUGE>", "ModIdx", "=", "AMDGPU", "::", "OpName", "::", "src1_modifiers", ";", "<BUGS>", "else", "if", "(", "OpNo", "==", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src2", ")", ")", "<BUGE>", "ModIdx", "=", "AMDGPU", "::", "OpName", "::", "src2_modifiers", ";", "assert", "(", "ModIdx", "!=", "-", "<NUM_LIT>", ")", ";", "ModIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "ModIdx", ")", ";", "MachineOperand", "&", "Mod", "=", "MI", "->", "getOperand", "(", "ModIdx", ")", ";", "<BUGS>", "unsigned", "Val", "=", "Mod", ".", "getImm", "(", ")", ";", "if", "(", "(", "Val", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "||", "!", "(", "Val", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "<BUGE>", "return", "false", ";", "<BUGS>", "if", "(", "!", "(", "Fold", ".", "ImmToFold", "&", "<NUM_LIT>", ")", ")", "{", "MachineOperand", "New", "=", "MachineOperand", "::", "CreateImm", "(", "(", "Fold", ".", "ImmToFold", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", ";", "if", "(", "!", "TII", "->", "isOperandLegal", "(", "*", "MI", ",", "OpNo", ",", "&", "New", ")", ")", "return", "false", ";", "Mod", ".", "setImm", "(", "Mod", ".", "getImm", "(", ")", "|", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Mod", ".", "setImm", "(", "Mod", ".", "getImm", "(", ")", "&", "~", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Old", ".", "ChangeToImmediate", "(", "(", "Fold", ".", "ImmToFold", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", ";", "<BUGE>", "return", "true", ";", "}", "<BUGS>", "MachineOperand", "New", "=", "MachineOperand", "::", "CreateImm", "(", "Fold", ".", "ImmToFold", "&", "<NUM_LIT>", ")", ";", "if", "(", "!", "TII", "->", "isOperandLegal", "(", "*", "MI", ",", "OpNo", ",", "&", "New", ")", ")", "return", "false", ";", "Mod", ".", "setImm", "(", "Mod", ".", "getImm", "(", ")", "&", "~", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Old", ".", "ChangeToImmediate", "(", "Fold", ".", "ImmToFold", "&", "<NUM_LIT>", ")", ";", "return", "true", ";", "<BUGE>", "}", "bool", "SIFoldOperands", "::", "updateOperand", "(", "FoldCandidate", "&", "Fold", ")", "const", "{" ]

[ "}" ]

[ "MCELFStreamer", "&", "SHUXITargetELFStreamer", "::", "getStreamer", "(", ")", "{", "return", "static_cast", "<", "MCELFStreamer", "&", ">", "(", "Streamer", ")", ";" ]

[ "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

[ "operands", "[", "n", "]", "=", "operands", "[", "n", "+", "<NUM_LIT>", "]", ";" ]

[ "if", "(", "MEM_P", "(", "operands", "[", "n", "]", ")", ")", "{", "rtx", "tem", "=", "operands", "[", "n", "]", ";" ]

[ "printOperand", "(", "MI", ",", "OpNum", ",", "STI", ",", "O", ")", ";" ]

[ "printOperand", "(", "MI", ",", "OpNum", "+", "<NUM_LIT>", ",", "STI", ",", "O", ")", ";", "}", "if", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{", "if", "(", "MI", "->", "getOperand", "(", "OpNum", "+", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "OpNum", "+", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{", "O", "<<", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "}", "else", "{", "}", "}", "else", "{", "O", "<<", "<STR_LIT>", "(, ", "<STR_LIT>", ";" ]

[ "<FIXS>", "if", "(", "FI", "==", "<NUM_LIT>", "||", "MFI", ".", "getStackID", "(", "FI", ")", "==", "TargetStackID", "::", "ScalableVector", ")", "{", "Base", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "TLI", "->", "getPointerTy", "(", "DL", ")", ")", ";", "OffImm", "=", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ",", "MVT", "::", "i64", ")", ";", "return", "true", ";", "}", "return", "false", ";", "<FIXE>" ]

[ "SDValue", "&", "OffImm", ")", "{", "const", "EVT", "MemVT", "=", "getMemVTFromNode", "(", "*", "(", "CurDAG", "->", "getContext", "(", ")", ")", ",", "Root", ")", ";", "const", "DataLayout", "&", "DL", "=", "CurDAG", "->", "getDataLayout", "(", ")", ";", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "FrameIndex", ")", "{", "int", "FI", "=", "cast", "FrameIndexSDNode", ">", "(", "N", ")", "->", "getIndex", "(", ")", ";", "<BUGS>", "Base", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "TLI", "->", "getPointerTy", "(", "DL", ")", ")", ";", "OffImm", "=", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ",", "MVT", "::", "i64", ")", ";", "return", "true", ";", "<BUGE>", "}", "if", "(", "MemVT", "==", "EVT", "(", ")", ")" ]

[ ")" ]

[ "(", "ashiftrt", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

[ ")", ")", "]" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "pc", ")", "(", "if_then_else", "(", "eq", "(", "reg", ":", "CC", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "pc", ")", "(", "label_ref", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ ")", ",", "UNSPEC_TLS", ")", ";" ]

[ "case", "TLS_MODEL_LOCAL_DYNAMIC", ":", "if", "(", "TARGET_GNU2_TLS", ")", "{", "gcc_assert", "(", "!", "TARGET_FDPIC", ")", ";", "reg", "=", "arm_tls_descseq_addr", "(", "x", ",", "reg", ")", ";", "tp", "=", "arm_load_tp", "(", "NULL_RTX", ")", ";", "dest", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tp", ",", "reg", ")", ";", "}", "else", "{", "if", "(", "TARGET_FDPIC", ")", "insns", "=", "arm_call_tls_get_addr", "(", "x", ",", "reg", ",", "&", "ret", ",", "TLS_LDM32_FDPIC", ")", ";", "else", "insns", "=", "arm_call_tls_get_addr", "(", "x", ",", "reg", ",", "&", "ret", ",", "TLS_LDM32", ")", ";", "eqv", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "const1_rtx", ")", ",", "UNSPEC_TLS", ")", ";", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_libcall_block", "(", "insns", ",", "dest", ",", "ret", ",", "eqv", ")", ";", "addend", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "x", ",", "GEN_INT", "(", "TLS_LDO32", ")", ")", ",", "UNSPEC_TLS", ")", ";", "addend", "=", "force_reg", "(", "SImode", ",", "gen_rtx_CONST", "(", "SImode", ",", "addend", ")", ")", ";", "dest", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "dest", ",", "addend", ")", ";", "}", "return", "dest", ";", "case", "TLS_MODEL_INITIAL_EXEC", ":", "if", "(", "TARGET_FDPIC", ")", "{", "sum", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "x", ",", "GEN_INT", "(", "TLS_IE32_FDPIC", ")", ")", ",", "UNSPEC_TLS", ")", ";", "reg", "=", "load_tls_operand", "(", "sum", ",", "reg", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "reg", ",", "reg", ",", "gen_rtx_REG", "(", "Pmode", ",", "FDPIC_REGNUM", ")", ")", ")", ";", "emit_move_insn", "(", "reg", ",", "gen_rtx_MEM", "(", "Pmode", ",", "reg", ")", ")", ";", "}", "else", "{", "labelno", "=", "GEN_INT", "(", "pic_labelno", "++", ")", ";", "label", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "labelno", ")", ",", "UNSPEC_PIC_LABEL", ")", ";", "label", "=", "gen_rtx_CONST", "(", "VOIDmode", ",", "label", ")", ";", "sum", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "x", ",", "GEN_INT", "(", "TLS_IE32", ")", ",", "label", ",", "GEN_INT", "(", "TARGET_ARM", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", ",", "UNSPEC_TLS", ")", ";", "reg", "=", "load_tls_operand", "(", "sum", ",", "reg", ")", ";", "if", "(", "TARGET_ARM", ")", "emit_insn", "(", "gen_tls_load_dot_plus_eight", "(", "reg", ",", "reg", ",", "labelno", ")", ")", ";", "else", "if", "(", "TARGET_THUMB2", ")", "emit_insn", "(", "gen_tls_load_dot_plus_four", "(", "reg", ",", "NULL", ",", "reg", ",", "labelno", ")", ")", ";", "else", "{", "emit_insn", "(", "gen_pic_add_dot_plus_four", "(", "reg", ",", "reg", ",", "labelno", ")", ")", ";", "emit_move_insn", "(", "reg", ",", "gen_const_mem", "(", "SImode", ",", "reg", ")", ")", ";", "}", "}", "tp", "=", "arm_load_tp", "(", "NULL_RTX", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "tp", ",", "reg", ")", ";", "case", "TLS_MODEL_LOCAL_EXEC", ":", "tp", "=", "arm_load_tp", "(", "NULL_RTX", ")", ";", "reg", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "x", ",", "GEN_INT", "(", "TLS_LE32", ")" ]

[ "<NUM_LIT>", ";" ]

[ "def", "A4_cmpbgt", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "IntRegs", ":", "$", "Rt32", ")", ",", "<STR_LIT>", ",", "tc_85d5d03f", ",", "TypeS_3op", ">", ",", "Enc_c2b48e", ",", "ImmRegRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "isCompare", "=" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op2", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op1", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Cn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Cm", ";" ]

[ "<FIXS>", "(", "neg", ":", "MVE_2", "(", "match_operand", ":", "MVE_2", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "MVE_2", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "unspec", ":", "MVE_2", "[", "(", "match_operand", ":", "MVE_2", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "VNEGQ_S", ")", ")", "<BUGE>", "]", "<STR_LIT>", "<STR_LIT>" ]

[ ";" ]

[ "return", "(", "bfloat16x8_t", ")", "_", "_", "a" ]

[ "let", "isExtendable", "=", "<NUM_LIT>", ";" ]

[ "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";" ]

[ "<STR_LIT>", ";" ]

[ "case", "Type", "::", "PointerTyID", ":", "{", "const", "PointerType", "*", "PT", "=", "cast", "<", "PointerType", ">", "(", "Ty", ")", ";", "const", "StructType", "*", "ST", "=", "dyn_cast", "<", "StructType", ">", "(", "PT", "->", "getElementType", "(", ")", ")", ";", "if", "(", "ST", "&&", "ST", "->", "isOpaque", "(", ")", ")", "{", "StringRef", "Name", "=", "ST", "->", "getName", "(", ")", ";", "if", "(", "Name", ".", "startswith", "(", "<STR_LIT>", "struct._image1d_t", "<STR_LIT>", ")", "||", "Name", ".", "startswith", "(", "<STR_LIT>", "struct._image1d_array_t", "<STR_LIT>", ")", "||", "Name", ".", "startswith", "(", "<STR_LIT>", "struct._image1d_buffer_t", "<STR_LIT>", ")", "||", "Name", ".", "startswith", "(", "<STR_LIT>", "struct._image2d_t", "<STR_LIT>", ")", "||", "Name", ".", "startswith", "(", "<STR_LIT>", "struct._image2d_array_t", "<STR_LIT>", ")", "||", "Name", ".", "startswith", "(", "<STR_LIT>", "struct._image3d_t", "<STR_LIT>", ")", ")", "{", "return", "<STR_LIT>", "_RWImg", "<STR_LIT>", ";", "}", "else", "if", "(", "Name", ".", "startswith", "(", "<STR_LIT>", "struct._sampler_t", "<STR_LIT>", ")", ")", "{", "return", "<STR_LIT>", "_Samp", "<STR_LIT>", ";", "}", "else", "if", "(", "Name", "==", "<STR_LIT>", "struct._counter32_t", "<STR_LIT>", "||", "Name", "==", "<STR_LIT>", "struct._event_t", "<STR_LIT>", ")", "{", "const", "DataLayout", "&", "DL", "=", "getDataLayout", "(", ")", ";", "return", "DL", ".", "getPointerSize", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "==", "<NUM_LIT>", "?", "<STR_LIT>", "u64", "<STR_LIT>", ":", "<STR_LIT>", "u32", "<STR_LIT>", ";", "}", "else", "{", "llvm_unreachable", "(", "<STR_LIT>", "unhandled struct type argument", "<STR_LIT>", ")", ";", "}", "}", "else", "{", "unsigned", "AS", "=", "PT", "->", "getAddressSpace", "(", ")", ";", "return", "getDataLayout", "(", ")", ".", "getPointerSize", "(", "AS", ")", "==", "<NUM_LIT>", "?", "<STR_LIT>", "u32", "<STR_LIT>", ":", "<STR_LIT>", "u64", "<STR_LIT>", ";", "}", "}", "case", "Type", "::", "StructTyID", ":", "return", "<STR_LIT>", "u8" ]

[ "UNSPEC_INSN_V2SADAS", ")", ")", "]" ]

[ "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ "<STR_LIT>", ")", ")", ")", "]" ]

[ "(", "smax", ":", "VF_HW", "(", "match_operand", ":", "VF_HW", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VF_HW", "<NUM_LIT>", "<STR_LIT>" ]

[ "fprintf", "(", "stderr", ",", "<STR_LIT>", "Failed to find HSA functions in ", "<STR_LIT>", "HSA_RUNTIME_LIB", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";" ]

[ "exit", "(", "<NUM_LIT>", ")", ";", "}", "DLSYM_FN", "(", "hsa_status_string", ")", "DLSYM_FN", "(", "hsa_agent_get_info", ")", "DLSYM_FN", "(", "hsa_init", ")", "DLSYM_FN", "(", "hsa_iterate_agents", ")", "DLSYM_FN", "(", "hsa_region_get_info", ")", "DLSYM_FN", "(", "hsa_queue_create", ")", "DLSYM_FN", "(", "hsa_agent_iterate_regions", ")", "DLSYM_FN", "(", "hsa_executable_destroy", ")", "DLSYM_FN", "(", "hsa_executable_create", ")", "DLSYM_FN", "(", "hsa_executable_global_variable_define", ")", "DLSYM_FN", "(", "hsa_executable_load_code_object", ")", "DLSYM_FN", "(", "hsa_executable_freeze", ")", "DLSYM_FN", "(", "hsa_signal_create", ")", "DLSYM_FN", "(", "hsa_memory_allocate", ")", "DLSYM_FN", "(", "hsa_memory_copy", ")", "DLSYM_FN", "(", "hsa_memory_free", ")", "DLSYM_FN", "(", "hsa_signal_destroy", ")", "DLSYM_FN", "(", "hsa_executable_get_symbol", ")", "DLSYM_FN", "(", "hsa_executable_symbol_get_info", ")", "DLSYM_FN", "(", "hsa_signal_wait_acquire", ")", "DLSYM_FN", "(", "hsa_signal_wait_relaxed", ")", "DLSYM_FN", "(", "hsa_signal_store_relaxed", ")", "DLSYM_FN", "(", "hsa_queue_destroy", ")", "DLSYM_FN", "(", "hsa_code_object_deserialize", ")", "DLSYM_FN", "(", "hsa_queue_load_write_index_relaxed", ")", "DLSYM_FN", "(", "hsa_queue_store_write_index_relaxed", ")", "DLSYM_FN", "(", "hsa_shut_down", ")", "return", ";", "fail", ":" ]

[ "emit_insn", "(", "(", "*", "gen", ")", "(", "dest", ",", "src0", ",", "src1", ")", ")", ";" ]

[ "if", "(", "src1", "==", "const0_rtx", ")", "src1", "=", "CONST0_RTX", "(", "src_mode", ")", ";", "else", "src1", "=", "gen_lowpart", "(", "src_mode", ",", "src1", ")", ";", "}" ]

[ "bool", "X86FrameInfo", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "bool", "isWin64", "=", "STI", ".", "isTargetWin64", "(", ")", ";", "unsigned", "SlotSize", "=", "STI", ".", "is64Bit", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "unsigned", "FPReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "unsigned", "CalleeFrameSize", "=", "<NUM_LIT>", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Opc", "=", "STI", ".", "is64Bit", "(", ")", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "<NUM_LIT>", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "Reg", "==", "FPReg", ")", "continue", ";", "if", "(", "!", "X86", "::", "VR128RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "isWin64", ")", "{", "CalleeFrameSize", "+=", "SlotSize", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "else", "{", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "-", "<NUM_LIT>", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "}", "X86FI", "->", "setCalleeSavedFrameSize", "(", "CalleeFrameSize", ")", ";", "return", "true", ";", "}" ]

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

[ "(", ")", ";" ]

[ "explicit", "X86FastISel", "(", "FunctionLoweringInfo", "&", "funcInfo", ",", "const", "TargetLibraryInfo", "*", "libInfo", ")", ":", "FastISel", "(", "funcInfo", ",", "libInfo", ")", "{", "Subtarget", "=", "&", "funcInfo", ".", "MF", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "X86ScalarSSEf64", "=", "Subtarget", "->", "hasSSE2", "(", ")", ";", "X86ScalarSSEf32", "=", "Subtarget", "->", "hasSSE1" ]

[ "DECL_ATTRIBUTES", "(", "new", "decl", ")", ")", ";" ]

[ "diff", "=", "(", "mips_get_compress_off_flags", "(", "DECL_ATTRIBUTES", "(", "olddecl", ")", ")", "^", "mips_get_compress_off_flags", "(", "DECL_ATTRIBUTES", "(", "new", "decl", ")", ")", ")", ";", "if", "(", "diff", ")", "error", "(", "<STR_LIT>", "%qE redeclared with conflicting %qs attributes", "<STR_LIT>", ",", "DECL_NAME", "(", "new", "decl", ")", ",", "mips_get_compress_off_name", "(", "diff", ")", ")", ";", "return", "merge_attributes", "(", "DECL_ATTRIBUTES", "(", "olddecl", ")", "," ]

[ "<FIXS>", "static", "int", "<FIXE>" ]

[ "ready", ",", "e_ready", ",", "reorder_type", "==", "<NUM_LIT>", ")", ";", "}", "<BUGS>", "int", "<BUGE>", "ia64_sched_reorder2", "(", "dump", ",", "sched_verbose", ",", "ready", ",", "pn_ready", ",", "clock_var", ")", "FILE", "*", "dump", "ATTRIBUTE_UNUSED", ";", "int", "sched_verbose", "ATTRIBUTE_UNUSED", ";" ]

[ "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(" ]

[ "v2i64", ")", "_", "<NUM_LIT>", ",", "(", "v2i64", ")", "_", "<NUM_LIT>", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_lsx_vavgr_d", "(", "(" ]

[ ",", "i32imm", ":", "$", "idx", ")", ";" ]

[ "def", "VecListFourDWordIndexed", ":", "Operand", "<", "i32", ">", "{", "let", "ParserMatchClass", "=", "VecListFourDWordIndexAsmOperand", ";", "let", "MIOperandInfo", "=", "(", "ops", "DPR", ":", "$", "Vd" ]

[ "<FIXS>", "<STR_LIT>", "<FIXE>" ]

[ "(", "call", "(", "mem", ":", "QI", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "{", "if", "(", "get_attr_op_type", "(", "insn", ")", "=", "=", "OP_TYPE_RR", ")", "return", "<STR_LIT>" ]

[ "if", "(", "Vec", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BUILD_VECTOR", ")", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "dl", ",", "ResultVT", ",", "makeArrayRef", "(", "Vec", "->", "op_begin", "(", ")", "+", "IdxVal", ",", "ElemsPerChunk", ")", ")", ";" ]

[ "unsigned", "Factor", "=", "VT", ".", "getSizeInBits", "(", ")", "/", "vectorWidth", ";", "EVT", "ResultVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "ElVT", ",", "VT", ".", "getVectorNumElements", "(", ")", "/", "Factor", ")", ";", "unsigned", "ElemsPerChunk", "=", "vectorWidth", "/", "ElVT", ".", "getSizeInBits", "(", ")", ";", "assert", "(", "isPowerOf2_32", "(", "ElemsPerChunk", ")", "&&", "<STR_LIT>", "Elements per chunk not power of 2", "<STR_LIT>", ")", ";", "IdxVal", "&=", "~", "(", "ElemsPerChunk", "-", "<NUM_LIT>", ")", ";" ]

[ ")", ";" ]

[ "std", "::", "vector", "<", "std", "::", "string", ">", "eint", "(", ")", "{", "return", "D", "(", "<STR_LIT>", "eint", "<STR_LIT>" ]

[ "Requires", "<", "[", "]", ">", ";" ]

[ "def", "MULRdRr", ":", "FRdRr", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "MainRegs", ":", "$", "lhs", ",", "MainRegs", ":", "$", "rhs", ")", ",", "<STR_LIT>", ",", "[", "]", ">", "," ]

[ ":" ]

[ "if", "(", "!", "Check", "(", "S", ",", "DecodeDPairSpacedRegisterClass", "(", "Inst", ",", "Rd", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "break", ";", "default", ":", "if", "(", "!", "Check", "(", "S", ",", "DecodeDPRRegisterClass", "(", "Inst", ",", "Rd", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "}", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "VLD3d8", ":", "case", "ARM", "::", "VLD3d16", ":", "case", "ARM", "::", "VLD3d32", ":", "case", "ARM", "::", "VLD3d8_UPD", ":", "case", "ARM", "::", "VLD3d16_UPD", ":", "case", "ARM", "::", "VLD3d32_UPD", ":", "case", "ARM", "::", "VLD4d8", ":", "case", "ARM", "::", "VLD4d16", ":", "case", "ARM", "::", "VLD4d32", ":", "case", "ARM", "::", "VLD4d8_UPD", ":", "case", "ARM", "::", "VLD4d16_UPD", ":", "case", "ARM", "::", "VLD4d32_UPD", ":", "if", "(", "!", "Check", "(", "S", ",", "DecodeDPRRegisterClass", "(", "Inst", ",", "(", "Rd", "+", "<NUM_LIT>", ")", "%", "<NUM_LIT>", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "break", ";", "case", "ARM", "::", "VLD3q8", ":", "case", "ARM", "::", "VLD3q16", ":", "case", "ARM", "::", "VLD3q32", ":", "case", "ARM", "::", "VLD3q8_UPD", ":", "case", "ARM", "::", "VLD3q16_UPD", ":", "case", "ARM", "::", "VLD3q32_UPD", ":", "case", "ARM", "::", "VLD4q8", ":", "case", "ARM", "::", "VLD4q16", ":", "case", "ARM", "::", "VLD4q32", ":", "case", "ARM", "::", "VLD4q8_UPD", ":", "case", "ARM", "::", "VLD4q16_UPD", ":", "case", "ARM", "::", "VLD4q32_UPD", ":", "if", "(", "!", "Check", "(", "S", ",", "DecodeDPRRegisterClass", "(", "Inst", ",", "(", "Rd", "+", "<NUM_LIT>", ")", "%", "<NUM_LIT>", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "default", ":", "break", ";", "}", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "VLD3d8", ":", "case", "ARM", "::", "VLD3d16", ":", "case", "ARM", "::", "VLD3d32", ":", "case", "ARM", "::", "VLD3d8_UPD", ":", "case", "ARM", "::", "VLD3d16_UPD", ":", "case", "ARM", "::", "VLD3d32_UPD", ":", "case", "ARM", "::", "VLD4d8", ":", "case", "ARM", "::", "VLD4d16", ":", "case", "ARM", "::", "VLD4d32", ":", "case", "ARM", "::", "VLD4d8_UPD", ":", "case", "ARM", "::", "VLD4d16_UPD", ":", "case", "ARM", "::", "VLD4d32_UPD", ":", "if", "(", "!", "Check", "(", "S", ",", "DecodeDPRRegisterClass", "(", "Inst", ",", "(", "Rd", "+", "<NUM_LIT>", ")", "%", "<NUM_LIT>", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "break", ";", "case", "ARM", "::", "VLD3q8", ":", "case", "ARM", "::", "VLD3q16", ":", "case", "ARM", "::", "VLD3q32", ":", "case", "ARM", "::", "VLD3q8_UPD", ":", "case", "ARM", "::", "VLD3q16_UPD", ":", "case", "ARM", "::", "VLD3q32_UPD", ":", "case", "ARM", "::", "VLD4q8", ":", "case", "ARM", "::", "VLD4q16", ":", "case", "ARM", "::", "VLD4q32", ":", "case", "ARM", "::", "VLD4q8_UPD", ":", "case", "ARM", "::", "VLD4q16_UPD", ":", "case", "ARM", "::", "VLD4q32_UPD", ":", "if", "(", "!", "Check", "(", "S", ",", "DecodeDPRRegisterClass", "(", "Inst", ",", "(", "Rd", "+", "<NUM_LIT>", ")", "%", "<NUM_LIT>", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "break", ";", "default", ":", "break", ";", "}", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "VLD4d8", ":", "case", "ARM", "::", "VLD4d16", ":", "case", "ARM", "::", "VLD4d32", ":", "case", "ARM", "::", "VLD4d8_UPD", ":", "case", "ARM", "::", "VLD4d16_UPD", ":", "case", "ARM", "::", "VLD4d32_UPD", ":", "if", "(", "!", "Check", "(", "S", ",", "DecodeDPRRegisterClass", "(", "Inst", ",", "(", "Rd", "+", "<NUM_LIT>", ")", "%", "<NUM_LIT>", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "break", ";", "case", "ARM", "::", "VLD4q8", ":", "case", "ARM", "::", "VLD4q16", ":", "case", "ARM", "::", "VLD4q32", ":", "case", "ARM", "::", "VLD4q8_UPD", ":", "case", "ARM", "::", "VLD4q16_UPD", ":", "case", "ARM", "::", "VLD4q32_UPD", ":", "if", "(", "!", "Check", "(", "S", ",", "DecodeDPRRegisterClass", "(", "Inst", ",", "(", "Rd", "+", "<NUM_LIT>", ")", "%", "<NUM_LIT>", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "break", ";", "default", ":", "break", ";", "}", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "VLD1d8wb_fixed", ":", "case", "ARM", "::", "VLD1d16wb_fixed", ":", "case", "ARM", "::", "VLD1d32wb_fixed", ":", "case", "ARM", "::", "VLD1d64wb_fixed", ":", "case", "ARM", "::", "VLD1d8wb_register", ":", "case", "ARM", "::", "VLD1d16wb_register", ":", "case", "ARM", "::", "VLD1d32wb_register", ":", "case", "ARM", "::", "VLD1d64wb_register" ]

[ "v4i32", ">", ";" ]

[ "def", "v4i32", ":", "LoadDFormVec", "<" ]

[ "FCmp64Libcalls", "[", "CmpInst", "::", "FCMP_ULE", "]", "=", "{", "{", "RTLIB", "::", "OGT_F64", ",", "CmpInst", "::", "ICMP_SLE", "}", "}", ";" ]

[ "FCmp64Libcalls", ".", "resize", "(", "CmpInst", "::", "LAST_FCMP_PREDICATE", "+", "<NUM_LIT>", ")", ";", "FCmp64Libcalls", "[", "CmpInst", "::", "FCMP_OEQ", "]", "=", "{", "{", "RTLIB", "::", "OEQ_F64", ",", "CmpInst", "::", "ICMP_EQ", "}", "}", ";", "FCmp64Libcalls", "[", "CmpInst", "::", "FCMP_OGE", "]", "=", "{", "{", "RTLIB", "::", "OGE_F64", ",", "CmpInst", "::", "ICMP_SGE", "}", "}", ";", "FCmp64Libcalls", "[", "CmpInst", "::", "FCMP_OGT", "]", "=", "{", "{", "RTLIB", "::", "OGT_F64", ",", "CmpInst", "::", "ICMP_SGT", "}", "}", ";", "FCmp64Libcalls", "[", "CmpInst", "::", "FCMP_OLE", "]", "=", "{", "{", "RTLIB", "::", "OLE_F64", ",", "CmpInst", "::", "ICMP_SLE", "}", "}", ";", "FCmp64Libcalls", "[", "CmpInst", "::", "FCMP_OLT", "]", "=", "{", "{", "RTLIB", "::", "OLT_F64", ",", "CmpInst", "::", "ICMP_SLT", "}", "}", ";", "FCmp64Libcalls", "[", "CmpInst", "::", "FCMP_ORD", "]", "=", "{", "{", "RTLIB", "::", "UO_F64", ",", "CmpInst", "::", "ICMP_EQ", "}", "}", ";", "FCmp64Libcalls", "[", "CmpInst", "::", "FCMP_UGE", "]", "=", "{", "{", "RTLIB", "::", "OLT_F64", ",", "CmpInst", "::", "ICMP_SGE", "}", "}", ";", "FCmp64Libcalls", "[", "CmpInst", "::", "FCMP_UGT", "]", "=", "{", "{", "RTLIB", "::", "OLE_F64", ",", "CmpInst", "::", "ICMP_SGT", "}", "}", ";" ]

[ "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";" ]

[ "<FIXS>", "xtensa_function_arg_advance", "(", "cumulative_args_t", "cum", ",", "machine_mode", "mode", ",", "<FIXE>" ]

[ "static", "void", "<BUGS>", "xtensa_function_arg_advance", "(", "cumulative_args_t", "cum", ",", "enum", "machine_mode", "mode", ",", "<BUGE>", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "int", "words", ",", "max", ";" ]

[ "<NUM_LIT>", "]", ";" ]

[ "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "let", "ResourceCycles", "=", "[", "<NUM_LIT>", "," ]

[ "<STR_LIT>", ")" ]

[ "(", "define_automaton" ]

[ "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "(", "match_operand", ":", "V64I", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "return", "getAddrGlobal", "(", "N", ",", "SDLoc", "(", "N", ")", ",", "Ty", ",", "DAG", ",", "(", "ABI", ".", "IsN32", "(", ")", "||", "ABI", ".", "IsN64", "(", ")", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "MachinePointerInfo", "::", "getGOT", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ")", ";" ]

[ "const", "GlobalObject", "*", "GO", "=", "GV", "->", "getAliaseeObject", "(", ")", ";", "if", "(", "GO", "&&", "TLOF", "->", "IsGlobalInSmallSection", "(", "GO", ",", "getTargetMachine", "(", ")", ")", ")", "return", "getAddrGPRel", "(", "N", ",", "SDLoc", "(", "N", ")", ",", "Ty", ",", "DAG", ",", "ABI", ".", "IsN64", "(", ")", ")", ";", "return", "Subtarget", ".", "hasSym32", "(", ")", "?", "getAddrNonPIC", "(", "N", ",", "SDLoc", "(", "N", ")", ",", "Ty", ",", "DAG", ")", ":", "getAddrNonPICSym64", "(", "N", ",", "SDLoc", "(", "N", ")", ",", "Ty", ",", "DAG", ")", ";", "}", "if", "(", "GV", "->", "hasLocalLinkage", "(", ")", ")", "return", "getAddrLocal", "(", "N", ",", "SDLoc", "(", "N", ")", ",", "Ty", ",", "DAG", ",", "ABI", ".", "IsN32", "(", ")", "||", "ABI", ".", "IsN64", "(", ")", ")", ";", "if", "(", "Subtarget", ".", "useXGOT", "(", ")", ")", "return", "getAddrGlobalLargeGOT", "(", "N", ",", "SDLoc", "(", "N", ")", ",", "Ty", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "MachinePointerInfo", "::", "getGOT", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ")", ";" ]

[ "let", "InputType", "=", "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";" ]