Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "}" ]

[ "bool", "MadeChange", "=", "false", ";", "MachineBasicBlock", "*", "MBB", ";", "unsigned", "int", "Cycles", "=", "<NUM_LIT>", ";", "for", "(", "DenseMap", "<", "MachineBasicBlock", "*", ",", "unsigned", "int", ">", "::", "iterator", "I", "=", "ReturnBBs", ".", "begin", "(", ")", ";", "I", "!=", "ReturnBBs", ".", "end", "(", ")", ";", "++", "I", ")", "{", "MBB", "=", "I", "->", "first", ";", "Cycles", "=", "I", "->", "second", ";", "if", "(", "Cycles", "<", "Threshold", ")", "{", "assert", "(", "MBB", "->", "size", "(", ")", ">", "<NUM_LIT>", "&&", "<STR_LIT>", "Basic block should contain at least a RET but is empty", "<STR_LIT>", ")", ";", "MachineBasicBlock", "::", "iterator", "ReturnLoc", "=", "--", "MBB", "->", "end", "(", ")", ";", "while", "(", "ReturnLoc", "->", "isDebugValue", "(", ")", ")", "--", "ReturnLoc", ";", "assert", "(", "ReturnLoc", "->", "isReturn", "(", ")", "&&", "!", "ReturnLoc", "->", "isCall", "(", ")", "&&", "<STR_LIT>", "Basic block does not end with RET", "<STR_LIT>", ")", ";", "addPadding", "(", "MBB", ",", "ReturnLoc", ",", "Threshold", "-", "Cycles", ")", ";", "NumBBsPadded", "++", ";", "MadeChange", "=", "true", ";", "}", "}", "return", "MadeChange", ";" ]

[ "bool", "ConstSplatVal", "=", "(", "Ld", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", "||", "Ld", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ConstantFP", ")", ";" ]

[ "if", "(", "UpperZeroOrUndef", "&&", "(", "(", "Op0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", ")", "||", "(", "Op0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ZERO_EXTEND", "&&", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", ")", ")", ")", "{", "SDValue", "BOperand", "=", "Op0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", "?", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ":", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "MVT", "MaskVT", "=", "BOperand", ".", "getSimpleValueType", "(", ")", ";", "MVT", "EltType", "=", "MVT", "::", "getIntegerVT", "(", "VT", ".", "getScalarSizeInBits", "(", ")", "*", "SeqLen", ")", ";", "if", "(", "(", "EltType", "==", "MVT", "::", "i64", "&&", "MaskVT", "==", "MVT", "::", "v8i1", ")", "||", "(", "EltType", "==", "MVT", "::", "i32", "&&", "MaskVT", "==", "MVT", "::", "v16i1", ")", ")", "{", "MVT", "BcstVT", "=", "MVT", "::", "getVectorVT", "(", "EltType", ",", "NumElts", "/", "SeqLen", ")", ";", "if", "(", "!", "VT", ".", "is512BitVector", "(", ")", "&&", "!", "Subtarget", ".", "hasVLX", "(", ")", ")", "{", "unsigned", "Scale", "=", "<NUM_LIT>", "/", "VT", ".", "getSizeInBits", "(", ")", ";", "BcstVT", "=", "MVT", "::", "getVectorVT", "(", "EltType", ",", "Scale", "*", "(", "NumElts", "/", "SeqLen", ")", ")", ";", "}", "SDValue", "Bcst", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "BcstVT", ",", "BOperand", ")", ";", "if", "(", "BcstVT", ".", "getSizeInBits", "(", ")", "!=", "VT", ".", "getSizeInBits", "(", ")", ")", "Bcst", "=", "extractSubVector", "(", "Bcst", ",", "<NUM_LIT>", ",", "DAG", ",", "dl", ",", "VT", ".", "getSizeInBits", "(", ")", ")", ";", "return", "DAG", ".", "getBitcast", "(", "VT", ",", "Bcst", ")", ";", "}", "}", "}", "unsigned", "NumUndefElts", "=", "UndefElements", ".", "count", "(", ")", ";", "if", "(", "!", "Ld", "||", "(", "NumElts", "-", "NumUndefElts", ")", "<=", "<NUM_LIT>", ")", "{", "APInt", "SplatValue", ",", "Undef", ";", "unsigned", "SplatBitSize", ";", "bool", "HasUndef", ";", "if", "(", "BVOp", "->", "isConstantSplat", "(", "SplatValue", ",", "Undef", ",", "SplatBitSize", ",", "HasUndef", ")", "&&", "SplatBitSize", ">", "VT", ".", "getScalarSizeInBits", "(", ")", "&&", "SplatBitSize", "<", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "if", "(", "isFoldableUseOfShuffle", "(", "BVOp", ")", ")", "return", "SDValue", "(", ")", ";", "const", "TargetLowering", "&", "TLI", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ";", "LLVMContext", "*", "Ctx", "=", "DAG", ".", "getContext", "(", ")", ";", "MVT", "PVT", "=", "TLI", ".", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "if", "(", "Subtarget", ".", "hasAVX", "(", ")", ")", "{", "if", "(", "SplatBitSize", "==", "<NUM_LIT>", "||", "SplatBitSize", "==", "<NUM_LIT>", "||", "(", "SplatBitSize", "<", "<NUM_LIT>", "&&", "Subtarget", ".", "hasAVX2", "(", ")", ")", ")", "{", "MVT", "CVT", "=", "MVT", "::", "getIntegerVT", "(", "SplatBitSize", ")", ";", "Type", "*", "ScalarTy", "=", "Type", "::", "getIntNTy", "(", "*", "Ctx", ",", "SplatBitSize", ")", ";", "Constant", "*", "C", "=", "Constant", "::", "getIntegerValue", "(", "ScalarTy", ",", "SplatValue", ")", ";", "SDValue", "CP", "=", "DAG", ".", "getConstantPool", "(", "C", ",", "PVT", ")", ";", "unsigned", "Repeat", "=", "VT", ".", "getSizeInBits", "(", ")", "/", "SplatBitSize", ";", "Align", "Alignment", "=", "cast", "<", "ConstantPoolSDNode", ">", "(", "CP", ")", "->", "getAlign", "(", ")", ";", "SDVTList", "Tys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "getVectorVT", "(", "CVT", ",", "Repeat", ")", ",", "MVT", "::", "Other", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "DAG", ".", "getEntryNode", "(", ")", ",", "CP", "}", ";", "MachinePointerInfo", "MPI", "=", "MachinePointerInfo", "::", "getConstantPool", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ";", "SDValue", "Brdcst", "=", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Tys", ",", "Ops", ",", "CVT", ",", "MPI", ",", "Alignment", ",", "MachineMemOperand", "::", "MOLoad", ")", ";", "return", "DAG", ".", "getBitcast", "(", "VT", ",", "Brdcst", ")", ";", "}", "if", "(", "SplatBitSize", ">", "<NUM_LIT>", ")", "{", "MVT", "CVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "Constant", "*", "VecC", "=", "getConstantVector", "(", "VT", ",", "SplatValue", ",", "SplatBitSize", ",", "*", "Ctx", ")", ";", "SDValue", "VCP", "=", "DAG", ".", "getConstantPool", "(", "VecC", ",", "PVT", ")", ";", "unsigned", "NumElm", "=", "SplatBitSize", "/", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "Align", "Alignment", "=", "cast", "<", "ConstantPoolSDNode", ">", "(", "VCP", ")", "->", "getAlign", "(", ")", ";", "Ld", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "getVectorVT", "(", "CVT", ",", "NumElm", ")", ",", "dl", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "VCP", ",", "MachinePointerInfo", "::", "getConstantPool", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ",", "Alignment", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "Ld", ")", ";", "}", "}", "}", "if", "(", "!", "Ld", "||", "NumElts", "-", "NumUndefElts", "!=", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "unsigned", "ScalarSize", "=", "Ld", ".", "getValueSizeInBits", "(", ")", ";", "if", "(", "!", "(", "UndefElements", "[", "<NUM_LIT>", "]", "||", "(", "ScalarSize", "!=", "<NUM_LIT>", "&&", "ScalarSize", "!=", "<NUM_LIT>", ")", ")", ")", "return", "SDValue", "(", ")", ";", "}" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_select", ":", "V2SI", "(", "unspec", ":", "V4SI", "[", "(", "match_operand", ":", "V4SF", "<NUM_LIT>" ]

[ "CP", ")", ";" ]

[ "SDValue", "X86TargetLowering", "::", "LowerConstantPool", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "ConstantPoolSDNode", "*", "CP", "=", "cast", "<", "ConstantPoolSDNode", ">", "(", "Op", ")", ";", "unsigned", "char", "OpFlag", "=", "<NUM_LIT>", ";", "unsigned", "WrapperKind", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "CodeModel", "::", "Model", "M", "=", "getTargetMachine", "(", ")", ".", "getCodeModel", "(", ")", ";", "if", "(", "Subtarget", "->", "isPICStyleRIPRel", "(", ")", "&&", "(", "M", "==", "CodeModel", "::", "Small", "||", "M", "==", "CodeModel", "::", "Kernel", ")", ")", "WrapperKind", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "if", "(", "Subtarget", "->", "isPICStyleGOT", "(", ")", ")", "OpFlag", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "if", "(", "Subtarget", "->", "isPICStyleStubPIC", "(", ")", ")", "OpFlag", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "SDValue", "Result", "=", "DAG", ".", "getTargetConstantPool", "(", "CP", "->", "getConstVal", "(", ")", ",", "getPointerTy", "(", ")", ",", "CP", "->", "getAlignment", "(", ")", ",", "CP", "->", "getOffset", "(", ")", ",", "OpFlag", ")", ";", "SDLoc", "DL", "(" ]

[ "}" ]

[ "setCPR1SizeFromPredicates", "(", "P", ")", ";", "setASESetFromPredicates", "(", "P", ")", ";", "setFpAbiFromPredicates", "(", "P", ")", ";", "OddSPReg", "=", "P", ".", "useOddSPReg", "(", ")", ";" ]

[ "<STR_LIT>", ";" ]

[ "let", "SuperClasses", "=", "[", "ShifterOperand", "]", ";", "let", "Name", "=" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V4QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "V4QI", "[", "(", "match_operand", ":", "V2HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "false", ";" ]

[ "bool", "MipsAsmParser", "::", "parseDirectiveCPReturn", "(", ")", "{", "getTargetStreamer", "(", ")", ".", "emitDirectiveCpreturn", "(", "CpSaveLocation", ",", "CpSaveLocationIsRegister", ")", ";", "return" ]

[ "DSP intrinisc insertion not enabled!", "<STR_LIT>", ")", ";" ]

[ "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM CGP: Mutating the tree..\\n", "<STR_LIT>", ")", ";", "IRBuilder", "<", ">", "Builder", "{", "Ctx", "}", ";", "for", "(", "auto", "*", "V", ":", "*", "Visited", ")", "{", "if", "(", "Sources", "->", "count", "(", "V", ")", ")", "continue", ";", "auto", "*", "I", "=", "cast", "<", "Instruction", ">", "(", "V", ")", ";", "if", "(", "Sinks", "->", "count", "(", "I", ")", ")", "continue", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "I", "->", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "Value", "*", "Op", "=", "I", "->", "getOperand", "(", "i", ")", ";", "if", "(", "(", "Op", "->", "getType", "(", ")", "==", "ExtTy", ")", "||", "!", "isa", "<", "IntegerType", ">", "(", "Op", "->", "getType", "(", ")", ")", ")", "continue", ";", "if", "(", "auto", "*", "Const", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "Op", ")", ")", "{", "Constant", "*", "NewConst", "=", "ConstantExpr", "::", "getZExt", "(", "Const", ",", "ExtTy", ")", ";", "I", "->", "setOperand", "(", "i", ",", "NewConst", ")", ";", "}", "else", "if", "(", "isa", "<", "UndefValue", ">", "(", "Op", ")", ")", "I", "->", "setOperand", "(", "i", ",", "UndefValue", "::", "get", "(", "ExtTy", ")", ")", ";", "}", "if", "(", "shouldPromote", "(", "I", ")", ")", "{", "I", "->", "mutateType", "(", "ExtTy", ")", ";", "Promoted", ".", "insert", "(", "I", ")", ";", "}", "}", "for", "(", "auto", "*", "V", ":", "*", "Visited", ")", "{", "auto", "*", "I", "=", "dyn_cast", "<", "Instruction", ">", "(", "V", ")", ";", "if", "(", "!", "I", ")", "continue", ";", "if", "(", "Sources", "->", "count", "(", "I", ")", "||", "Sinks", "->", "count", "(", "I", ")", ")", "continue", ";", "if", "(", "!", "shouldPromote", "(", "I", ")", "||", "SafeToPromote", "->", "count", "(", "I", ")", "||", "NewInsts", ".", "count", "(", "I", ")", ")", "continue", ";", "assert", "(", "EnableDSP", "&&", "<STR_LIT>" ]

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

[ "unsigned", "Opcode", "=", "getOpcodeForOffset", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "Reg", ")", "?", "HighOpcode", ":", "LowOpcode", ",", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ";", "MI", ".", "setDesc", "(", "get" ]

[ "return", "ARM", "::", "VLD1q16PseudoWB_register", ";" ]

[ "case", "ARM", "::", "VLD1d8wb_fixed", ":", "return", "ARM", "::", "VLD1d8wb_register", ";", "case", "ARM", "::", "VLD1d16wb_fixed", ":", "return", "ARM", "::", "VLD1d16wb_register", ";", "case", "ARM", "::", "VLD1d32wb_fixed", ":", "return", "ARM", "::", "VLD1d32wb_register", ";", "case", "ARM", "::", "VLD1d64wb_fixed", ":", "return", "ARM", "::", "VLD1d64wb_register", ";", "case", "ARM", "::", "VLD1q8wb_fixed", ":", "return", "ARM", "::", "VLD1q8wb_register", ";", "case", "ARM", "::", "VLD1q16wb_fixed", ":", "return", "ARM", "::", "VLD1q16wb_register", ";", "case", "ARM", "::", "VLD1q32wb_fixed", ":", "return", "ARM", "::", "VLD1q32wb_register", ";", "case", "ARM", "::", "VLD1q64wb_fixed", ":", "return", "ARM", "::", "VLD1q64wb_register", ";", "case", "ARM", "::", "VLD1q8PseudoWB_fixed", ":", "return", "ARM", "::", "VLD1q8PseudoWB_register", ";", "case", "ARM", "::", "VLD1q16PseudoWB_fixed", ":" ]

[ "}" ]

[ "extern", "_", "_", "inline", "void", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_storeu_epi64", "(", "void", "*", "_", "_", "P", ",", "_", "_", "m256i", "_", "_", "A", ")", "{", "*", "(", "_", "_", "m256i_u", "*", ")", "_", "_", "P", "=", "(", "_", "_", "m256i_u", ")", "_", "_", "A", ";" ]

[ "}" ]

[ "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op1", ";", "let", "SrcB", "=", "op2", ";", "let", "OperandType", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "OperandType", "{", "<NUM_LIT>", "}", "=", "sw", "{", "<NUM_LIT>", "}", ";", "let", "Switches", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Switches", "{", "<NUM_LIT>", "}", "=", "sw", "{", "<NUM_LIT>", "}", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "HasImm", "=", "hasImm", ";", "let", "immOpNum", "=", "<NUM_LIT>", ";", "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ ":", "{" ]

[ "Address", "SavedAddr", "=", "Addr", ";", "uint64_t", "TmpOffset", "=", "Addr", ".", "getOffset", "(", ")", ";", "for", "(", "gep_type_iterator", "GTI", "=", "gep_type_begin", "(", "U", ")", ",", "E", "=", "gep_type_end", "(", "U", ")", ";", "GTI", "!=", "E", ";", "++", "GTI", ")", "{", "const", "Value", "*", "Op", "=", "GTI", ".", "getOperand", "(", ")", ";", "if", "(", "StructType", "*", "STy", "=", "dyn_cast", "<", "StructType", ">", "(", "*", "GTI", ")", ")", "{", "const", "StructLayout", "*", "SL", "=", "DL", ".", "getStructLayout", "(", "STy", ")", ";", "unsigned", "Idx", "=", "cast", "<", "ConstantInt", ">", "(", "Op", ")", "->", "getZExtValue", "(", ")", ";", "TmpOffset", "+=", "SL", "->", "getElementOffset", "(", "Idx", ")", ";", "}", "else", "{", "uint64_t", "S", "=", "DL", ".", "getTypeAllocSize", "(", "GTI", ".", "getIndexedType", "(", ")", ")", ";", "for", "(", ";", ";", ")", "{", "if", "(", "const", "ConstantInt", "*", "CI", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "Op", ")", ")", "{", "TmpOffset", "+=", "CI", "->", "getSExtValue", "(", ")", "*", "S", ";", "break", ";", "}", "if", "(", "S", "==", "<NUM_LIT>", "&&", "Addr", ".", "isRegBase", "(", ")", "&&", "Addr", ".", "getReg", "(", ")", "==", "<NUM_LIT>", ")", "{", "Addr", ".", "setReg", "(", "getRegForValue", "(", "Op", ")", ")", ";", "break", ";", "}", "if", "(", "canFoldAddIntoGEP", "(", "U", ",", "Op", ")", ")", "{", "ConstantInt", "*", "CI", "=", "cast", "<", "ConstantInt", ">", "(", "cast", "<", "AddOperator", ">", "(", "Op", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "TmpOffset", "+=", "CI", "->", "getSExtValue", "(", ")", "*", "S", ";", "Op", "=", "cast", "<", "AddOperator", ">", "(", "Op", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "continue", ";", "}", "goto", "unsupported_gep", ";", "}", "}", "}", "Addr", ".", "setOffset", "(", "TmpOffset", ")", ";", "if", "(", "computeAddress", "(", "U", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Addr", ")", ")", "return", "true", ";", "Addr", "=", "SavedAddr", ";", "unsupported_gep", ":", "break", ";", "}", "case", "Instruction", "::", "Alloca", ":", "{", "const", "AllocaInst", "*", "AI", "=", "cast", "<", "AllocaInst", ">", "(", "Obj", ")", ";", "DenseMap", "<", "const", "AllocaInst", "*", ",", "int", ">", "::", "iterator", "SI", "=", "FuncInfo", ".", "StaticAllocaMap", ".", "find", "(", "AI", ")", ";", "if", "(", "SI", "!=", "FuncInfo", ".", "StaticAllocaMap", ".", "end", "(", ")", ")", "{", "Addr", ".", "setKind", "(", "Address", "::", "FrameIndexBase", ")", ";", "Addr", ".", "setFI", "(", "SI", "->", "second", ")", ";", "return", "true", ";", "}", "break", ";", "}", "case", "Instruction", "::", "Add", ":", "{", "const", "Value", "*", "LHS", "=", "U", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "const", "Value", "*", "RHS", "=", "U", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "isa", "<", "ConstantInt", ">", "(", "LHS", ")", ")", "std", "::", "swap", "(", "LHS", ",", "RHS", ")", ";", "if", "(", "const", "ConstantInt", "*", "CI", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "RHS", ")", ")", "{", "Addr", ".", "setOffset", "(", "Addr", ".", "getOffset", "(", ")", "+", "CI", "->", "getSExtValue", "(", ")", ")", ";", "return", "computeAddress", "(", "LHS", ",", "Addr", ")", ";", "}", "Address", "Backup", "=", "Addr", ";", "if", "(", "computeAddress", "(", "LHS", ",", "Addr", ")", "&&", "computeAddress", "(", "RHS", ",", "Addr", ")", ")", "return", "true", ";", "Addr", "=", "Backup", ";", "break", ";", "}", "case", "Instruction", "::", "Sub" ]

[ "if", "(", "TLI", "->", "isLegalAddressingMode", "(", "*", "DL", ",", "AM", ",", "GEP", "->", "getResultElementType", "(", ")", ",", "GEP", "->", "getPointerAddressSpace", "(", ")", ")", ")", "continue", ";" ]

[ "CallSite", "CS", "(", "const_cast", "<", "Instruction", "*", ">", "(", "&", "I", ")", ")", ";", "if", "(", "CS", ")", "{", "Function", "*", "Callee", "=", "CS", ".", "getCalledFunction", "(", ")", ";", "if", "(", "!", "Callee", "||", "Callee", "->", "isDeclaration", "(", ")", ")", "{", "++", "FI", ".", "InstCount", ";", "continue", ";", "}", "if", "(", "&", "F", "==", "Callee", ")", "continue", ";", "visit", "(", "*", "Callee", ")", ";", "auto", "Loc", "=", "FIM", ".", "find", "(", "Callee", ")", ";", "assert", "(", "Loc", "!=", "FIM", ".", "end", "(", ")", "&&", "<STR_LIT>", "No func info", "<STR_LIT>", ")", ";", "FI", ".", "MemInstCount", "+=", "Loc", "->", "second", ".", "MemInstCount", ";", "FI", ".", "InstCount", "+=", "Loc", "->", "second", ".", "InstCount", ";", "FI", ".", "IAMInstCount", "+=", "Loc", "->", "second", ".", "IAMInstCount", ";", "FI", ".", "LSMInstCount", "+=", "Loc", "->", "second", ".", "LSMInstCount", ";", "}", "else", "if", "(", "auto", "*", "GEP", "=", "dyn_cast", "<", "GetElementPtrInst", ">", "(", "&", "I", ")", ")", "{", "TargetLoweringBase", "::", "AddrMode", "AM", ";", "auto", "*", "Ptr", "=", "GetPointerBaseWithConstantOffset", "(", "GEP", ",", "AM", ".", "BaseOffs", ",", "*", "DL", ")", ";", "AM", ".", "BaseGV", "=", "dyn_cast_or_null", "<", "GlobalValue", ">", "(", "const_cast", "<", "Value", "*", ">", "(", "Ptr", ")", ")", ";", "AM", ".", "HasBaseReg", "=", "!", "AM", ".", "BaseGV", ";" ]

[ "::", "FeatureMips3", "]", ";" ]

[ "return", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", "[", "Mips" ]

[ ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

[ "return", "(", "_", "_", "mmask8", ")", "_", "_", "builtin_ia32_cmppd512_mask", "(", "(", "_", "_", "v8df", ")", "_", "_", "X", ",", "(", "_", "_", "v8df", ")", "_", "_", "Y", ",", "_", "CMP_NLT_US" ]

[ ";" ]

[ "def", "VectorIndex8Operand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "}", "def", "VectorIndex16Operand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "}", "def", "VectorIndex32Operand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "}", "def", "VectorIndex64Operand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "}", "def", "VectorIndex8", ":", "Operand", "<", "i32", ">", ",", "ImmLeaf", "<", "i32", ",", "[", "{", "return", "(", "(", "uint64_t", ")", "Imm", ")", "<", "<NUM_LIT>", ";", "}", "]", ">", "{", "let", "ParserMatchClass", "=", "VectorIndex8Operand", ";", "let", "PrintMethod", "=", "<STR_LIT>" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "MCSymbolRefExpr", "::", "VK_ARM_GOTOFF", ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "MCSymbolRefExpr", "::", "VK_ARM_TPOFF", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "MCSymbolRefExpr", "::", "VK_ARM_GOTTPOFF", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "MCSymbolRefExpr", "::", "VK_ARM_GOT", ";" ]

[ "i64", ")", ",", "VPg", ",", "VX", ",", "VExp", ")", ";" ]

[ "SDValue", "VX", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "DL", ",", "XVT", ",", "DAG", ".", "getUNDEF", "(", "XVT", ")", ",", "X", ",", "Zero", ")", ";", "SDValue", "VExp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "DL", ",", "ExpVT", ",", "DAG", ".", "getUNDEF", "(", "ExpVT", ")", ",", "Exp", ",", "Zero", ")", ";", "SDValue", "VPg", "=", "getPTrue", "(", "DAG", ",", "DL", ",", "XVT", ".", "changeVectorElementType", "(", "MVT", "::", "i1", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "SDValue", "FScale", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INTRINSIC_WO_CHAIN", ",", "DL", ",", "XVT", ",", "DAG", ".", "getConstant", "(", "Intrinsic", "::", "aarch64_sve_fscale", ",", "DL", ",", "MVT", "::" ]

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

[ "void", "m68hc11_emit_libcall", "(", "const", "char", "*", "name", ",", "enum", "rtx_code", "code", ",", "enum", "machine_mode", "dmode", ",", "enum", "machine_mode", "smode", ",", "int", "noperands", ",", "rtx", "*", "operands", ")", "{", "rtx", "ret", ";", "rtx", "insns", ";", "rtx", "libcall", ";", "rtx", "equiv", ";", "start_sequence", "(", ")", ";", "libcall", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "name", ")", ";", "switch", "(", "noperands", ")", "{", "case", "<NUM_LIT>", ":", "ret", "=", "emit_library_call_value", "(", "libcall", ",", "NULL_RTX", ",", "LCT_CONST", ",", "dmode", ",", "<NUM_LIT>", ",", "operands", "[", "<NUM_LIT>", "]", ",", "smode", ")", ";", "equiv", "=", "gen_rtx_fmt_e", "(", "code", ",", "dmode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "ret", "=", "emit_library_call_value", "(", "libcall", ",", "NULL_RTX", ",", "LCT_CONST", ",", "dmode", ",", "<NUM_LIT>", ",", "operands", "[", "<NUM_LIT>", "]", ",", "smode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "smode", ")", ";", "equiv", "=", "gen_rtx_fmt_ee", "(", "code", ",", "dmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "insns", "=", "get_insns", "(", ")", ";" ]

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

[ "(", "define_code_iterator", "any_div", "[", "div" ]

[ "}" ]

[ "def", "C2_pxfer_map", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "PredRegs", ":", "$", "Ps4", ")", ",", "<STR_LIT>", ",", "tc_640086b5", ",", "TypeMAPPING", ">", "{", "let", "isPseudo", "=", "<NUM_LIT>", ";", "let", "isCodeGenOnly", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "[", "[", "fallthrough", "]", "]", ";", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "[", "[", "fallthrough", "]", "]", ";", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "Opcode", "=", "Mips", "::", "XOR", ";", "break", ";", "case", "Mips", "::", "ATOMIC_LOAD_UMIN_I8_POSTRA", ":", "<BUGS>", "IsUnsigned", "=", "true", ";", "IsMin", "=", "true", ";", "break", ";", "<BUGE>", "case", "Mips", "::", "ATOMIC_LOAD_UMIN_I16_POSTRA", ":", "IsUnsigned", "=", "true", ";", "<BUGS>", "IsMin", "=", "true", ";", "break", ";", "<BUGE>", "case", "Mips", "::", "ATOMIC_LOAD_MIN_I8_POSTRA", ":", "<BUGS>", "SEOp", "=", "Mips", "::", "SEB", ";", "IsMin", "=", "true", ";", "break", ";", "<BUGE>", "case", "Mips", "::", "ATOMIC_LOAD_MIN_I16_POSTRA", ":", "IsMin", "=", "true", ";", "break", ";", "case", "Mips", "::", "ATOMIC_LOAD_UMAX_I8_POSTRA", ":", "<BUGS>", "IsUnsigned", "=", "true", ";", "IsMax", "=", "true", ";", "break", ";", "<BUGE>", "case", "Mips", "::", "ATOMIC_LOAD_UMAX_I16_POSTRA", ":", "IsUnsigned", "=", "true", ";", "<BUGS>", "IsMax", "=", "true", ";", "break", ";", "<BUGE>", "case", "Mips", "::", "ATOMIC_LOAD_MAX_I8_POSTRA", ":", "<BUGS>", "SEOp", "=", "Mips", "::", "SEB", ";", "IsMax", "=", "true", ";", "break", ";", "<BUGE>", "case", "Mips", "::", "ATOMIC_LOAD_MAX_I16_POSTRA", ":", "IsMax", "=", "true", ";", "break", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_bypass", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>" ]

[ "SDValue", "AMDGPUTargetLowering", "::", "SplitVectorLoad", "(", "const", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "<NUM_LIT>", ")", "return", "ScalarizeVectorLoad", "(", "Op", ",", "DAG", ")", ";", "LoadSDNode", "*", "Load", "=", "cast", "<", "LoadSDNode", ">", "(", "Op", ")", ";", "SDValue", "BasePtr", "=", "Load", "->", "getBasePtr", "(", ")", ";", "EVT", "PtrVT", "=", "BasePtr", ".", "getValueType", "(", ")", ";", "EVT", "MemVT", "=", "Load", "->", "getMemoryVT", "(", ")", ";", "SDLoc", "SL", "(", "Op", ")", ";", "const", "MachinePointerInfo", "&", "SrcValue", "=", "Load", "->", "getMemOperand", "(", ")", "->", "getPointerInfo", "(", ")", ";", "EVT", "LoVT", ",", "HiVT", ";", "EVT", "LoMemVT", ",", "HiMemVT", ";", "SDValue", "Lo", ",", "Hi", ";", "std", "::", "tie", "(", "LoVT", ",", "HiVT", ")", "=", "DAG", ".", "GetSplitDestVTs", "(", "VT", ")", ";", "std", "::", "tie", "(", "LoMemVT", ",", "HiMemVT", ")", "=", "DAG", ".", "GetSplitDestVTs", "(", "MemVT", ")", ";", "std", "::", "tie", "(", "Lo", ",", "Hi", ")", "=", "DAG", ".", "SplitVector", "(", "Op", ",", "SL", ",", "LoVT", ",", "HiVT", ")", ";", "unsigned", "Size", "=", "LoMemVT", ".", "getStoreSize", "(", ")", ";", "unsigned", "BaseAlign", "=", "Load", "->", "getAlignment", "(", ")", ";", "unsigned", "HiAlign", "=", "MinAlign", "(", "BaseAlign", ",", "Size", ")", ";", "SDValue", "LoLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "LoVT", ",", "Load", "->", "getChain", "(", ")", ",", "BasePtr", ",", "SrcValue", ",", "LoMemVT", ",", "Load", "->", "isVolatile", "(", ")", ",", "Load", "->", "isNonTemporal", "(", ")", ",", "Load", "->", "isInvariant", "(", ")", ",", "BaseAlign", ")", ";", "SDValue", "HiPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "SL", ",", "PtrVT", ",", "BasePtr", ",", "DAG", ".", "getConstant", "(", "Size", ",", "SL", ",", "PtrVT", ")", ")", ";", "SDValue", "HiLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "HiVT", ",", "Load", "->", "getChain", "(", ")", ",", "HiPtr", ",", "SrcValue", ".", "getWithOffset", "(", "LoMemVT", ".", "getStoreSize", "(", ")", ")", ",", "HiMemVT", ",", "Load", "->", "isVolatile", "(", ")", ",", "Load", "->", "isNonTemporal", "(", ")", ",", "Load", "->", "isInvariant", "(", ")", ",", "HiAlign", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "DAG", ".", "getNode", "(", "ISD", "::", "CONCAT_VECTORS", ",", "SL", ",", "VT", ",", "LoLoad", ",", "HiLoad", ")", ",", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "SL", ",", "MVT", "::", "Other", ",", "LoLoad", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "HiLoad", ".", "getValue", "(", "<NUM_LIT>", ")", ")", "}", ";", "return", "DAG", ".", "getMergeValues", "(", "Ops", ",", "SL", ")", ";", "}" ]

[ "Split", "a", "vector", "load", "into", "2", "loads", "of", "half", "the", "vector", "." ]

[ "}" ]

[ "unsigned", "getGlobalBaseReg", "(", ")", "const", "{", "return", "GlobalBaseReg", ";" ]

[ "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2STRi12", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";" ]

[ "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FI", ")", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";" ]

[ "[", "<NUM_LIT>", "]", ">", "Table", ")", "{" ]

[ "static", "const", "uint16_t", "*", "lookupAVX512", "(", "unsigned", "opcode", ",", "unsigned", "domain", ",", "ArrayRef", "<", "uint16_t" ]

[ "_", "_", "c", ")", ";" ]

[ "return", "(", "int8x16_t", ")", "_", "_", "builtin_aarch64_raddhn2v8hi", "(", "_", "_", "a", ",", "_", "_", "b", "," ]

[ "}" ]

[ "let", "isCall", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "R29", "]", ";", "let", "Defs", "=", "[", "PC", ",", "R31", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPredicable", "=", "<NUM_LIT>", ";", "let", "hasSideEffects", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "return", "T", ";" ]

[ "}", "MCOperand", "&", "ImmOp", "=", "Inst", ".", "getOperand", "(", "i", ")", ";", "const", "auto", "*", "HE", "=", "static_cast", "<", "const", "HexagonMCExpr", "*", ">", "(", "ImmOp", ".", "getExpr", "(", ")", ")", ";", "int32_t", "V", "=", "cast", "<", "MCConstantExpr", ">", "(", "HE", "->", "getExpr", "(", ")", ")", "->", "getValue", "(", ")", ";", "auto", "*", "NewCE", "=", "MCConstantExpr", "::", "create", "(", "V", "/", "int32_t", "(", "VectorSize", ")", ",", "Ctx", ")", ";", "auto", "*", "NewHE", "=", "HexagonMCExpr", "::", "create", "(", "NewCE", ",", "Ctx", ")", ";", "T", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "NewHE", ")", ")", ";", "}" ]

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

[ "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isMoveImm", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

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

[ "(", "fix", ":", "V2SI", "(", "match_operand", ":", "V2SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "condition_rtx", "=", "mt_generate_compare", "(", "code", ",", "op0", ",", "op1", ")", ";", "<FIXE>" ]

[ "if", "(", "!", "reg_or_0_operand", "(", "op1", ",", "SImode", ")", ")", "op1", "=", "copy_to_mode_reg", "(", "SImode", ",", "op1", ")", ";", "<BUGS>", "condition_rtx", "=", "ms1_generate_compare", "(", "code", ",", "op0", ",", "op1", ")", ";", "<BUGE>", "loc_ref", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "loc", ")", ";", "emit_jump_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "condition_rtx", "," ]

[ "const", "int", "_", "_", "R", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m128h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mask_fmadd_round_sh", "(", "_", "_", "m128h", "_", "_", "W", ",", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128h", "_", "_", "A", ",", "_", "_", "m128h", "_", "_", "B", "," ]

[ "}" ]

[ "if", "(", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isLRReservedForRA", "(", ")", ")", "{", "if", "(", "!", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "NoVRegs", ")", ")", "markSuperRegs", "(", "Reserved", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ "]" ]

[ "(", "unspec", ":", "VH", "[", "(", "match_operand", ":", "VH", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_LOONGSON_PSHUFH", ")", ")" ]

[ "cstr", ">", "{" ]

[ "class", "EncodedI", "<", "string", "cstr", ",", "list", "<", "dag", ">", "pattern", ">", ":", "AArch64Inst", "<", "NormalFrm", "," ]

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

[ "(", "and", "(", "match_code", "<STR_LIT>", ")", "(", "match_test", "<STR_LIT>", ")" ]

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

[ "def", "A2_paddf", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ",", "IntRegs", ":", "$", "Rt32", ")", ",", "<STR_LIT>", ",", "tc_4c5ba658", ",", "TypeALU32_3op", ">", ",", "Enc_ea4c54", ",", "PredNewRel", ",", "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", "isPredicated", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "def", "ICXWriteResGroup20", ":", "SchedWriteRes", "<", "[", "ICXPort6", ",", "ICXPort0156", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "let", "ResourceCycles", "=", "[", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ";" ]

[ "}" ]

[ "if", "(", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "FIRST_STACK_REG", ")", "return", "output_387_ffreep", "(", "operands", ",", "<NUM_LIT>", ")", ";", "return", "<STR_LIT>", "fstp\\t%y0", "<STR_LIT>", ";", "}", "if", "(", "STACK_TOP_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "return", "<STR_LIT>", "fld%Z1\\t%y1", "<STR_LIT>", ";", "return", "<STR_LIT>", "fst\\t%y0", "<STR_LIT>", ";", "}", "else", "if", "(", "MEM_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "gcc_assert", "(", "REG_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "if", "(", "find_regno_note", "(", "insn", ",", "REG_DEAD", ",", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ")", "return", "<STR_LIT>", "fstp%Z0\\t%y0", "<STR_LIT>", ";", "else", "{", "if", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "XFmode", ")", "return", "<STR_LIT>", "fstp%Z0\\t%y0\\n\\tfld%Z0\\t%y0", "<STR_LIT>", ";", "else", "return", "<STR_LIT>", "fst%Z0\\t%y0", "<STR_LIT>", ";" ]

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

[ "(", "define_int_attr", "rot", "[", "(", "UNSPEC_CADD90", "<STR_LIT>", ")", "(", "UNSPEC_CADD270", "<STR_LIT>", ")", "]", ")", "(", "define_int_attr", "cadd_subadd", "[", "(", "UNSPEC_CADD90", "<STR_LIT>", ")", "(", "UNSPEC_CADD270" ]

[ "->", "emitELFHeaderFlagsCG", "(", "*", "Subtarget", ")", ";" ]

[ "if", "(", "MipsELFStreamer", "*", "MES", "=", "dyn_cast", "<", "MipsELFStreamer", ">", "(", "&", "OutStreamer", ")", ")", "MES" ]

[ "}" ]

[ "}", "if", "(", "(", "CC", "==", "ISD", "::", "SETNE", "||", "CC", "==", "ISD", "::", "SETEQ", ")", "&&", "RHS", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SUB", ")", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "RHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "if", "(", "C", "->", "getAPIntValue", "(", ")", "==", "<NUM_LIT>", "&&", "RHS", ".", "hasOneUse", "(", ")", ")", "{", "SDValue", "addV", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "SDLoc", "(", "N", ")", ",", "RHS", ".", "getValueType", "(", ")", ",", "LHS", ",", "RHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "return", "DAG", ".", "getSetCC", "(", "SDLoc", "(", "N", ")", ",", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "addV", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "addV", ".", "getValueType", "(", ")", ")", ",", "CC", ")", ";", "}", "return", "SDValue", "(", ")", ";" ]

[ ",", "Ctx", ")", ";" ]

[ "static", "MCDisassembler", "*", "createSparcDisassembler", "(", "const", "Target", "&", "T", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCContext", "&", "Ctx", ")", "{", "return", "new", "SparcDisassembler", "(", "STI" ]

[ "numElem", ")", ";", "break", ";" ]

[ "if", "(", "DCI", ".", "isBeforeLegalize", "(", ")", "||", "!", "Subtarget", "->", "hasNEON", "(", ")", "||", "N0", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "BUILD_VECTOR", "||", "N1", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "BUILD_VECTOR", ")", "return", "SDValue", "(", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "VT", ".", "isInteger", "(", ")", "||", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i64", ")", "return", "SDValue", "(", ")", ";", "if", "(", "N0", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "EXTRACT_VECTOR_ELT", ")", "return", "SDValue", "(", ")", ";", "SDValue", "Vec", "=", "N0", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDNode", "*", "V", "=", "Vec", ".", "getNode", "(", ")", ";", "unsigned", "nextIndex", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "N0", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "N0", "->", "getOperand", "(", "i", ")", "->", "getOpcode", "(", ")", "==", "ISD", "::", "EXTRACT_VECTOR_ELT", "&&", "N1", "->", "getOperand", "(", "i", ")", "->", "getOpcode", "(", ")", "==", "ISD", "::", "EXTRACT_VECTOR_ELT", ")", "{", "SDValue", "ExtVec0", "=", "N0", "->", "getOperand", "(", "i", ")", ";", "SDValue", "ExtVec1", "=", "N1", "->", "getOperand", "(", "i", ")", ";", "if", "(", "V", "!=", "ExtVec0", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", "||", "V", "!=", "ExtVec1", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ")", "return", "SDValue", "(", ")", ";", "ConstantSDNode", "*", "C0", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "ExtVec0", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "ConstantSDNode", "*", "C1", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "ExtVec1", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "C0", "||", "!", "C1", "||", "C0", "->", "getZExtValue", "(", ")", "!=", "nextIndex", "||", "C1", "->", "getZExtValue", "(", ")", "!=", "nextIndex", "+", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "nextIndex", "+=", "<NUM_LIT>", ";", "}", "else", "return", "SDValue", "(", ")", ";", "}", "if", "(", "nextIndex", "!=", "Vec", ".", "getValueType", "(", ")", ".", "getVectorNumElements", "(", ")", "||", "Vec", ".", "getValueType", "(", ")", ".", "getVectorElementType", "(", ")", "==", "VT", ".", "getVectorElementType", "(", ")", ")", "return", "SDValue", "(", ")", ";", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "const", "TargetLowering", "&", "TLI", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ";", "SDLoc", "dl", "(", "N", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", ";", "Ops", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "Intrinsic", "::", "arm_neon_vpaddls", ",", "dl", ",", "TLI", ".", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ")", ";", "Ops", ".", "push_back", "(", "Vec", ")", ";", "MVT", "widenType", ";", "unsigned", "numElem", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "EVT", "inputLaneType", "=", "Vec", ".", "getValueType", "(", ")", ".", "getVectorElementType", "(", ")", ";", "switch", "(", "inputLaneType", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "i8", ":", "widenType", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i16", "," ]

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

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

[ "}", ";" ]

[ "switch", "(", "NT", ")", "{", "case", "Function", ":", "return", "{", "<STR_LIT>", "function", "<STR_LIT>", ",", "<STR_LIT>", "end_function", "<STR_LIT>", "}", ";", "case", "Block", ":", "return", "{", "<STR_LIT>", "block", "<STR_LIT>", ",", "<STR_LIT>", "end_block", "<STR_LIT>", "}", ";", "case", "Loop", ":", "return", "{", "<STR_LIT>", "loop", "<STR_LIT>", ",", "<STR_LIT>", "end_loop", "<STR_LIT>", "}", ";", "case", "Try", ":", "return", "{", "<STR_LIT>", "try", "<STR_LIT>", ",", "<STR_LIT>", "end_try", "<STR_LIT>", "}", ";", "case", "If", ":", "return", "{", "<STR_LIT>", "if", "<STR_LIT>", ",", "<STR_LIT>", "end_if", "<STR_LIT>", "}", ";", "case", "Else", ":", "return", "{", "<STR_LIT>", "else", "<STR_LIT>", ",", "<STR_LIT>", "end_if", "<STR_LIT>" ]

[ "bool", "Z80oldMachineLateOptimization", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetSubtargetInfo", "&", "STI", "=", "MF", ".", "getSubtarget", "(", ")", ";", "assert", "(", "MF", ".", "getRegInfo", "(", ")", ".", "tracksLiveness", "(", ")", "&&", "<STR_LIT>", "Liveness not being tracked!", "<STR_LIT>", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "if", "(", "!", "MF", ".", "getRegInfo", "(", ")", ".", "isPhysRegModified", "(", "Z80old", "::", "F", ")", ")", "{", "return", "Changed", ";", "}", "APInt", "FlagsZero", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "FlagsOne", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "bool", "UnusedFlags", "=", "true", ";", "for", "(", "MachineBasicBlock", "*", "Successor", ":", "MBB", ".", "successors", "(", ")", ")", "if", "(", "Successor", "->", "isLiveIn", "(", "Z80old", "::", "F", ")", ")", "{", "UnusedFlags", "=", "false", ";", "}", "for", "(", "auto", "I", "=", "MBB", ".", "rbegin", "(", ")", ",", "E", "=", "MBB", ".", "rend", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "UnusedFlags", ")", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "Z80old", "::", "LD8ri", ":", "if", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "Z80old", "::", "A", "&&", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{", "I", "->", "setDesc", "(", "TII", "->", "get", "(", "Z80old", "::", "XOR8ar", ")", ")", ";", "I", "->", "RemoveOperand", "(", "<NUM_LIT>", ")", ";", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setIsUse", "(", ")", ";", "I", "->", "addImplicitDefUseOperands", "(", "MF", ")", ";", "for", "(", "auto", "&", "Op", ":", "I", "->", "uses", "(", ")", ")", "{", "Op", ".", "setIsUndef", "(", ")", ";", "}", "FlagsZero", "=", "HalfCarry", "|", "Subtract", "|", "Carry", ";", "FlagsOne", "=", "<NUM_LIT>", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "'", "!", "'", ")", ";", "Changed", "=", "true", ";", "}", "break", ";", "case", "Z80old", "::", "LD24ri", ":", "if", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "Z80old", "::", "UHL", "&&", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", ")", "{", "int", "Imm", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "if", "(", "Imm", "==", "<NUM_LIT>", "||", "Imm", "==", "-", "<NUM_LIT>", ")", "{", "while", "(", "I", "->", "getNumOperands", "(", ")", ")", "{", "I", "->", "RemoveOperand", "(", "<NUM_LIT>", ")", ";", "}", "I", "->", "setDesc", "(", "TII", "->", "get", "(", "Z80old", "::", "SBC24aa", ")", ")", ";", "I", "->", "addImplicitDefUseOperands", "(", "MF", ")", ";", "for", "(", "auto", "&", "Op", ":", "I", "->", "uses", "(", ")", ")", "{", "Op", ".", "setIsUndef", "(", ")", ";", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ".", "getReverse", "(", ")", ",", "I", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Imm", "?", "Z80old", "::", "SCF", ":", "Z80old", "::", "OR8ar", ")", ")", ";", "if", "(", "!", "Imm", ")", "{", "MIB", ".", "addReg", "(", "Z80old", "::", "A", ")", ";", "}", "I", "=", "*", "MIB", ";", "for", "(", "auto", "&", "Op", ":", "I", "->", "uses", "(", ")", ")", "{", "Op", ".", "setIsUndef", "(", ")", ";", "}", "FlagsZero", "=", "(", "Imm", "&", "(", "Sign", "|", "HalfCarry", "|", "Carry", ")", ")", "|", "(", "~", "Imm", "&", "Zero", ")", "|", "ParityOverflow", ";", "FlagsOne", "=", "(", "~", "Imm", "&", "(", "Sign", "|", "HalfCarry", "|", "Carry", ")", ")", "|", "(", "Imm", "&", "Zero", ")", "|", "Subtract", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "'", "!", "'", ")", ";", "Changed", "=", "true", ";", "}", "}", "break", ";", "case", "Z80old", "::", "POP24r", ":", "if", "(", "!", "OptSize", "&&", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "Z80old", "::", "UHL", ")", "{", "auto", "P", "=", "std", "::", "next", "(", "I", ")", ";", "if", "(", "P", "!=", "E", "&&", "P", "->", "getOpcode", "(", ")", "==", "Z80old", "::", "PUSH24r", "&&", "Z80old", "::", "O24RegClass", ".", "contains", "(", "P", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", "{", "while", "(", "I", "->", "getNumOperands", "(", ")", "!=", "I", "->", "getNumExplicitOperands", "(", ")", ")", "{", "I", "->", "RemoveOperand", "(", "I", "->", "getNumExplicitOperands", "(", ")", ")", ";", "}", "I", "->", "setDesc", "(", "TII", "->", "get", "(", "Z80old", "::", "ADD24ao", ")", ")", ";", "I", "->", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "Z80old", "::", "UHL", ",", "false", ")", ")", ";", "I", "->", "addOperand", "(", "P", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "I", "->", "addImplicitDefUseOperands", "(", "MF", ")", ";", "I", "->", "findRegisterDefOperand", "(", "Z80old", "::", "F", ")", "->", "setIsDead", "(", ")", ";", "while", "(", "P", "->", "getNumOperands", "(", ")", ")", "{", "P", "->", "RemoveOperand", "(", "<NUM_LIT>", ")", ";", "}", "P", "->", "setDesc", "(", "TII", "->", "get", "(", "Z80old", "::", "SBC24aa", ")", ")", ";", "P", "->", "addImplicitDefUseOperands", "(", "MF", ")", ";", "for", "(", "auto", "&", "Op", ":", "P", "->", "uses", "(", ")", ")", "{", "Op", ".", "setIsUndef", "(", ")", ";", "}", "I", "=", "*", "BuildMI", "(", "MBB", ",", "P", ".", "getReverse", "(", ")", ",", "P", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Z80old", "::", "OR8ar", ")", ")", ".", "addReg", "(", "Z80old", "::", "A", ")", ";", "for", "(", "auto", "&", "Op", ":", "I", "->", "uses", "(", ")", ")", "{", "Op", ".", "setIsUndef", "(", ")", ";", "}", "FlagsZero", "=", "Sign", "|", "ParityOverflow", "|", "Subtract", "|", "Carry", ";", "FlagsOne", "=", "Zero", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "'", "!", "'", ")", ";", "Changed", "=", "true", ";", "}", "}", "break", ";", "default", ":", "computeKnownFlags", "(", "*", "I", ",", "FlagsZero", ",", "FlagsOne", ")", ";", "break", ";", "}", "UnusedFlags", "|=", "I", "->", "definesRegister", "(", "Z80old", "::", "F", ")", ";", "if", "(", "MachineOperand", "*", "FlagsUse", "=", "I", "->", "findRegisterUseOperand", "(", "Z80old", "::", "F", ")", ")", "{", "UnusedFlags", "&=", "FlagsUse", "->", "isUndef", "(", ")", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "(", "UnusedFlags", "?", "<STR_LIT>", "unused", "<STR_LIT>", ":", "<STR_LIT>", "used", "<STR_LIT>", ")", "<<", "'", "\\t", "'", ";", "I", "->", "dump", "(", ")", ")", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "'", "\\n", "'", ")", ";", "}", "return", "Changed", ";", "}" ]

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

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

[ "let", "OutOperandList", "=", "(", "outs", "IRF", ":", "$", "dst", ")", ";", "let", "InOperandList", "=", "(", "ins", "IRF", ":", "$", "income", ",", "TPCImm", "<", "i32imm", ">", ":", "$", "src", ",", "DimMask", ":", "$", "mask", ",", "SwitchSet", ":", "$", "sw", ",", "SPred", ":", "$", "pred", ")", ";", "let", "Pattern", "=", "pattern", ";", "let", "Itinerary", "=", "IIC_StoreComplexOp", ";", "bits", "<", "<NUM_LIT>", ">", "mask", ";", "bits", "<", "<NUM_LIT>", ">", "dst", ";", "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "SrcA", "=", "src", ";", "let", "SrcB", "=", "{", "<NUM_LIT>", ",", "mask", ",", "<NUM_LIT>", "}", ";", "let", "SrcExtra", "=", "dst", ";", "let", "Switches", "=", "sw", ";", "let", "Switches", "{", "<NUM_LIT>", "}", "=", "MaskInReg", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "VectorPred", "=", "<NUM_LIT>", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "HasImm", "=", "<NUM_LIT>", ";" ]

[ "if", "(", "matchVectorShuffleWithUNPCK", "(", "MaskVT", ",", "V1", ",", "V2", ",", "Shuffle", ",", "IsUnary", ",", "Mask", ",", "DL", ",", "DAG", ",", "Subtarget", ")", ")", "{" ]

[ "}", "if", "(", "isTargetShuffleEquivalent", "(", "Mask", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", "&&", "(", "AllowFloatDomain", "||", "!", "Subtarget", ".", "hasSSE41", "(", ")", ")", ")", "{", "Shuffle", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "SrcVT", "=", "DstVT", "=", "MVT", "::", "v4f32", ";", "return", "true", ";", "}", "}", "if", "(", "(", "(", "MaskVT", "==", "MVT", "::", "v8i16", "||", "MaskVT", "==", "MVT", "::", "v16i8", ")", "&&", "Subtarget", ".", "hasSSE2", "(", ")", ")", "||", "(", "(", "MaskVT", "==", "MVT", "::", "v16i16", "||", "MaskVT", "==", "MVT", "::", "v32i8", ")", "&&", "Subtarget", ".", "hasInt256", "(", ")", ")", "||", "(", "(", "MaskVT", "==", "MVT", "::", "v32i16", "||", "MaskVT", "==", "MVT", "::", "v64i8", ")", "&&", "Subtarget", ".", "hasBWI", "(", ")", ")", ")", "{", "if", "(", "matchVectorShuffleWithPACK", "(", "MaskVT", ",", "SrcVT", ",", "V1", ",", "V2", ",", "Shuffle", ",", "Mask", ",", "DAG", ",", "Subtarget", ")", ")", "{", "DstVT", "=", "MaskVT", ";", "return", "true", ";", "}", "}", "if", "(", "(", "MaskVT", "==", "MVT", "::", "v4f32", "&&", "Subtarget", ".", "hasSSE1", "(", ")", ")", "||", "(", "MaskVT", ".", "is128BitVector", "(", ")", "&&", "Subtarget", ".", "hasSSE2", "(", ")", ")", "||", "(", "MaskVT", ".", "is256BitVector", "(", ")", "&&", "<NUM_LIT>", "<=", "EltSizeInBits", "&&", "Subtarget", ".", "hasAVX", "(", ")", ")", "||", "(", "MaskVT", ".", "is256BitVector", "(", ")", "&&", "Subtarget", ".", "hasAVX2", "(", ")", ")", "||", "(", "MaskVT", ".", "is512BitVector", "(", ")", "&&", "Subtarget", ".", "hasAVX512", "(", ")", ")", ")", "{" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "not", ":", "HI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "base", ";" ]

[ "return", "general_operand", "(", "op", ",", "mode", ")" ]

[ "(", "match_code", "<STR_LIT>", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "=", "=", "MEM", "&", "&", "misaligned_operand", "(", "op", ",", "mode", ")", "&", "&", "!", "address_operand", "(", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "SImode", ")", ")", "return", "<NUM_LIT>" ]

[ ")" ]

[ "(", "unspec_volatile", ":", "SI", "[", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "UNSPEC_VOLATILE_LLW", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_maskz_cvtepi64_pd", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m512i", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m512d", ")", "_", "_", "builtin_ia32_cvtqq2pd512_mask", "(", "(", "_", "_", "v8di", ")", "_", "_", "A", ",", "(", "_", "_", "v8df", ")", "_", "mm512_setzero_pd", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

[ "<FIXS>", "tls_symbolic_operand", "(", "rtx", "op", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "<FIXE>" ]

[ "enum", "tls_model", "<BUGS>", "tls_symbolic_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "<BUGE>", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "SYMBOL_REF", ")", "return", "TLS_MODEL_NONE", ";" ]

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

[ "let", "Rd", "=", "PC", ".", "Num", ";", "let", "Rs1", "=", "FP", ".", "Num", ";", "let", "P" ]

[ "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM CGP: Mutation complete\\n", "<STR_LIT>", ")", ";" ]

[ "this", "->", "SafeWrap", "=", "&", "SafeWrap", ";", "for", "(", "auto", "*", "I", ":", "Sinks", ")", "{", "if", "(", "auto", "*", "Call", "=", "dyn_cast", "<", "CallInst", ">", "(", "I", ")", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "Call", "->", "getNumArgOperands", "(", ")", ";", "++", "i", ")", "{", "Value", "*", "Arg", "=", "Call", "->", "getArgOperand", "(", "i", ")", ";", "TruncTysMap", "[", "Call", "]", ".", "push_back", "(", "Arg", "->", "getType", "(", ")", ")", ";", "}", "}", "else", "if", "(", "auto", "*", "Switch", "=", "dyn_cast", "<", "SwitchInst", ">", "(", "I", ")", ")", "TruncTysMap", "[", "I", "]", ".", "push_back", "(", "Switch", "->", "getCondition", "(", ")", "->", "getType", "(", ")", ")", ";", "else", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "I", "->", "getNumOperands", "(", ")", ";", "++", "i", ")", "TruncTysMap", "[", "I", "]", ".", "push_back", "(", "I", "->", "getOperand", "(", "i", ")", "->", "getType", "(", ")", ")", ";", "}", "}", "for", "(", "auto", "*", "V", ":", "Visited", ")", "{", "if", "(", "!", "isa", "<", "TruncInst", ">", "(", "V", ")", "||", "Sources", ".", "count", "(", "V", ")", ")", "continue", ";", "auto", "*", "Trunc", "=", "cast", "<", "TruncInst", ">", "(", "V", ")", ";", "TruncTysMap", "[", "Trunc", "]", ".", "push_back", "(", "Trunc", "->", "getDestTy", "(", ")", ")", ";", "}", "PrepareWrappingAdds", "(", ")", ";", "ExtendSources", "(", ")", ";", "PromoteTree", "(", ")", ";", "ConvertTruncs", "(", ")", ";", "TruncateSinks", "(", ")", ";", "Cleanup", "(", ")", ";" ]

[ "Register", "DstReg", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";" ]

[ "bool", "ExpandPseudo", "::", "expandExtractElementF64", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "bool", "FP64", ")", "const", "{", "const", "MachineOperand", "&", "Op1", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "const", "MachineOperand", "&", "Op2", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "(", "Op1", ".", "isReg", "(", ")", "&&", "Op1", ".", "isUndef", "(", ")", ")", "||", "(", "Op2", ".", "isReg", "(", ")", "&&", "Op2", ".", "isUndef", "(", ")", ")", ")", "{", "Register", "DstReg", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Mips", "::", "IMPLICIT_DEF", ")", ",", "DstReg", ")", ";", "return", "true", ";", "}", "if", "(", "I", "->", "getNumOperands", "(", ")", "==", "<NUM_LIT>", "&&", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "Mips", "::", "SP", ")", "{" ]

[ "<NUM_LIT>", ";" ]

[ "def", "ICXWriteResGroup114", ":", "SchedWriteRes", "<", "[", "ICXPort0", ",", "ICXPort4", ",", "ICXPort5", ",", "ICXPort237", ",", "ICXPort0156", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=" ]

[ "return", "DecodeFPR128RegisterClass", "(", "Inst", ",", "RegNo", ",", "Addr", ",", "Decoder", ")", ";" ]

[ "static", "DecodeStatus", "DecodeFPR128_loRegisterClass", "(", "MCInst", "&", "Inst", ",", "unsigned", "RegNo", ",", "uint64_t", "Addr", ",", "const", "void", "*", "Decoder", ")", "{", "if", "(", "RegNo", ">", "<NUM_LIT>", ")", "return", "Fail", ";" ]

[ "}" ]

[ "int", "Idx", "=", "ShuffV", "[", "i", "]", ";", "if", "(", "(", "Idx", ">=", "<NUM_LIT>", "&&", "Idx", "<", "LHSMaxIdx", ")", "||", "(", "Idx", ">=", "RHSMinIdx", "&&", "Idx", "<", "RHSMaxIdx", ")", ")", "ShuffV", "[", "i", "]", "+=", "Subtarget", ".", "isLittleEndian", "(", ")", "?", "HalfVec", ":", "HalfVec", "-", "ValidLaneWidth", ";" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "GPR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "zero_extract", ":", "GPR", "(", "match_operand", ":", "GPR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "\t", "<STR_LIT>", ")" ]

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

[ "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "break", ";", "default", ":", "fprintf", "(", "stderr", ",", "<STR_LIT>", "Bad value for -mchar-bytesize: %s\\n", "<STR_LIT>", ",", "pdp10_string_bytesize", ")", ";", "exit", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "pdp10_char_bytesize", "!=", "<NUM_LIT>", ")", "{", "char_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "char_type_node", ",", "pdp10_char_bytesize", ",", "!", "flag_signed_char", ")", ";", "signed_char_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "signed_char_type_node", ",", "pdp10_char_bytesize", ",", "<NUM_LIT>", ")", ";", "unsigned_char_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "unsigned_char_type_node", ",", "pdp10_char_bytesize", ",", "<NUM_LIT>", ")", ";", "}", "}", "short16_integer_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "short16_integer_type_node", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "ggc_add_tree_root", "(", "&", "short16_integer_type_node", ",", "<NUM_LIT>", ")", ";", "short16_unsigned_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "short16_unsigned_type_node", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "ggc_add_tree_root", "(", "&", "short16_unsigned_type_node", ",", "<NUM_LIT>", ")", ";", "int32_integer_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "int32_integer_type_node", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "ggc_add_tree_root", "(", "&", "int32_integer_type_node", ",", "<NUM_LIT>", ")", ";", "int32_unsigned_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "int32_unsigned_type_node", ",", "<NUM_LIT>", "," ]

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

[ "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "if", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "}", "}" ]

[ "Parser", ".", "eatToEndOfStatement", "(", ")", ";" ]

[ "bool", "ARMAsmParser", "::", "parseDirectiveThumbSet", "(", "SMLoc", "L", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "StringRef", "Name", ";", "if", "(", "Parser", ".", "parseIdentifier", "(", "Name", ")", ")", "{", "TokError", "(", "<STR_LIT>", "expected identifier after '.thumb_set'", "<STR_LIT>", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Comma", ")", ")", "{", "TokError", "(", "<STR_LIT>", "expected comma after name '", "<STR_LIT>", "+", "Name", "+", "<STR_LIT>", "'", "<STR_LIT>", ")", ";" ]

[ "bool", "MOSCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "ArrayRef", "<", "Register", ">>", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "auto", "&", "TFI", "=", "static_cast", "<", "const", "MOSFrameLowering", "&", ">", "(", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ")", ";", "if", "(", "TFI", ".", "isISR", "(", "MF", ")", ")", "MIRBuilder", ".", "buildInstr", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "SmallVector", "<", "ArgInfo", ">", "SplitArgs", ";", "unsigned", "Idx", "=", "<NUM_LIT>", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "DL", ".", "getTypeStoreSize", "(", "Arg", ".", "getType", "(", ")", ")", ".", "isZero", "(", ")", ")", "continue", ";", "ArgInfo", "OrigArg", "{", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ",", "Idx", "}", ";", "setArgFlags", "(", "OrigArg", ",", "Idx", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ")", ";", "++", "Idx", ";", "}", "MOSIncomingArgsHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ")", ";", "MOSValueAssigner", "Assigner", "(", "true", ",", "MRI", ",", "MF", ")", ";", "if", "(", "!", "determineAndHandleAssignments", "(", "Handler", ",", "Assigner", ",", "SplitArgs", ",", "MIRBuilder", ",", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ")", "return", "false", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "{", "auto", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "MOSFunctionInfo", ">", "(", ")", ";", "FuncInfo", "->", "setVarArgsStackIndex", "(", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateFixedObject", "(", "<NUM_LIT>", ",", "Assigner", ".", "StackOffset", ",", "true", ")", ")", ";", "}", "return", "true", ";", "}" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "}" ]

[ "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "{", "switch", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "case", "QImode", ":", "emit_insn", "(", "gen_addqi3_carry", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "val", ",", "compare_op", ")", ")", ";", "break", ";", "case", "HImode", ":", "emit_insn", "(", "gen_addhi3_carry", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "val", ",", "compare_op", ")", ")", ";", "break", ";", "case", "SImode", ":", "emit_insn", "(", "gen_addsi3_carry", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "val", ",", "compare_op", ")", ")", ";", "break", ";", "case", "DImode", ":", "emit_insn", "(", "gen_adddi3_carry_rex64", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "val", ",", "compare_op", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "return", "<NUM_LIT>", ";" ]

[ "if", "(", "&", "*", "MBBI", "==", "&", "*", "Paired", ".", "I", ")", "{" ]

[ "DenseSet", "<", "unsigned", ">", "PhysRegUsesToMove", ";", "addDefsUsesToList", "(", "*", "CI", ".", "I", ",", "RegDefsToMove", ",", "PhysRegUsesToMove", ")", ";", "MachineBasicBlock", "::", "iterator", "E", "=", "std", "::", "next", "(", "Paired", ".", "I", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "std", "::", "next", "(", "CI", ".", "I", ")", ";", "for", "(", ";", "MBBI", "!=", "E", ";", "++", "MBBI", ")", "{", "if", "(", "(", "getInstClass", "(", "MBBI", "->", "getOpcode", "(", ")", ",", "*", "TII", ")", "!=", "InstClass", ")", "||", "(", "getInstSubclass", "(", "MBBI", "->", "getOpcode", "(", ")", ",", "*", "TII", ")", "!=", "InstSubclass", ")", ")", "{", "if", "(", "MBBI", "->", "hasUnmodeledSideEffects", "(", ")", ")", "{", "return", "false", ";", "}", "if", "(", "MBBI", "->", "mayLoadOrStore", "(", ")", "&&", "(", "!", "memAccessesCanBeReordered", "(", "*", "CI", ".", "I", ",", "*", "MBBI", ",", "AA", ")", "||", "!", "canMoveInstsAcrossMemOp", "(", "*", "MBBI", ",", "InstsToMove", ",", "AA", ")", ")", ")", "{", "InstsToMove", ".", "push_back", "(", "&", "*", "MBBI", ")", ";", "addDefsUsesToList", "(", "*", "MBBI", ",", "RegDefsToMove", ",", "PhysRegUsesToMove", ")", ";", "continue", ";", "}", "addToListsIfDependent", "(", "*", "MBBI", ",", "RegDefsToMove", ",", "PhysRegUsesToMove", ",", "InstsToMove", ")", ";", "continue", ";", "}", "if", "(", "MBBI", "->", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "int", "Swizzled", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MBBI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "swz", ")", ";", "if", "(", "Swizzled", "!=", "-", "<NUM_LIT>", "&&", "MBBI", "->", "getOperand", "(", "Swizzled", ")", ".", "getImm", "(", ")", ")", "return", "false", ";", "if", "(", "addToListsIfDependent", "(", "*", "MBBI", ",", "RegDefsToMove", ",", "PhysRegUsesToMove", ",", "InstsToMove", ")", ")", "continue", ";" ]

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

[ "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPseudo", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "dl", ",", "MVT", "::", "f64", ",", "Src", ")", ";", "<FIXE>", "<FIXS>", "Tmp", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "f64", ",", "Src", ")", ";", "<FIXE>", "<FIXS>", "Tmp", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "f64", ",", "Src", ")", ";", "<FIXE>" ]

[ "SDValue", "PPCTargetLowering", "::", "LowerFP_TO_SINT", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "assert", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ".", "isFloatingPoint", "(", ")", ")", ";", "SDValue", "Src", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Src", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", ")", "<BUGS>", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "MVT", "::", "f64", ",", "Src", ")", ";", "<BUGE>", "SDValue", "Tmp", ";", "switch", "(", "Op", ".", "getValueType", "(", ")", ".", "getSimpleVT", "(", ")", ")", "{", "default", ":", "assert", "(", "<NUM_LIT>", "&&", "<STR_LIT>", "Unhandled FP_TO_SINT type in custom expander!", "<STR_LIT>", ")", ";", "case", "MVT", "::", "i32", ":", "<BUGS>", "Tmp", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "f64", ",", "Src", ")", ";", "<BUGE>", "break", ";", "case", "MVT", "::", "i64", ":", "<BUGS>", "Tmp", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "f64", ",", "Src", ")", ";", "<BUGE>", "break", ";", "}" ]

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

[ "auto", "RegOpcode", "=", "OutMI", ".", "getOpcode", "(", ")", ";", "auto", "StackOpcode", "=", "WebAssembly", "::", "getStackOpcode", "(", "RegOpcode", ")", ";", "assert", "(", "StackOpcode", "!=", "-", "<NUM_LIT>", "&&", "<STR_LIT>", "Failed to stackify instruction", "<STR_LIT>", ")", ";", "OutMI", ".", "setOpcode", "(", "StackOpcode", ")", ";", "for", "(", "auto", "I", "=", "OutMI", ".", "getNumOperands", "(", ")", ";", "I", ";", "--", "I", ")", "{", "auto", "&", "MO", "=", "OutMI", ".", "getOperand", "(", "I", "-", "<NUM_LIT>", ")", ";", "if", "(", "MO", ".", "isReg", "(" ]

[ "static", "const", "char", "*", "match_to_right_bracket", "(", "void", ")", "{", "int", "lastpos", "=", "pos", "-", "<NUM_LIT>", ";", "while", "(", "lastpos", "<", "LINELEN", "-", "<NUM_LIT>", "&&", "linebuf", "[", "lastpos", "+", "<NUM_LIT>", "]", "!=", "'", "]", "'", ")", "{", "if", "(", "linebuf", "[", "lastpos", "+", "<NUM_LIT>", "]", "==", "'", "\\n", "'", ")", "fatal", "(", "<STR_LIT>", "no ']' found before end of line.\\n", "<STR_LIT>", ")", ";", "++", "lastpos", ";", "}", "if", "(", "lastpos", ">=", "LINELEN", "-", "<NUM_LIT>", ")", "{", "diag", "(", "lastpos", ",", "<STR_LIT>", "line length overrun.\\n", "<STR_LIT>", ")", ";", "exit", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "lastpos", "<", "pos", ")", "return", "<NUM_LIT>", ";", "char", "*", "buf", "=", "(", "char", "*", ")", "malloc", "(", "lastpos", "-", "pos", "+", "<NUM_LIT>", ")", ";", "memcpy", "(", "buf", ",", "&", "linebuf", "[", "pos", "]", ",", "lastpos", "-", "pos", "+", "<NUM_LIT>", ")", ";", "buf", "[", "lastpos", "-", "pos", "+", "<NUM_LIT>", "]", "=", "'", "\\0", "'", ";", "pos", "=", "lastpos", "+", "<NUM_LIT>", ";", "return", "buf", ";", "}" ]

[ "Match", "a", "string", "up", "to", "but", "not", "including", "a", "'", "]", "'", ",", "and", "return", "its", "value", ",", "or", "zero", "if", "there", "is", "nothing", "before", "the", "'", "]", "'", ".", "Error", "if", "we", "do", "n't", "find", "such", "a", "character", "." ]

[ "X", ";" ]

[ "static", "MCCodeGenInfo", "*", "createNPEngineMCCdoeGenInfo", "(", "StringRef", "TT", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", "{", "MCCodeGenInfo", "*", "X", "=", "new", "MCCodeGenInfo", "(", ")", ";", "if", "(", "RM", "==", "Reloc", "::", "Default", ")", "{", "RM", "=", "Reloc", "::", "Static", ";", "}", "if", "(", "CM", "==", "CodeModel", "::", "Default", ")", "{", "CM", "=", "CodeModel", "::", "Small", ";", "}", "if", "(", "CM", "!=", "CodeModel", "::", "Small", "&&", "CM", "!=", "CodeModel", "::", "Large", ")", "{", "report_fatal_error", "(", "<STR_LIT>", "Target only supports CodeModel Small or Large", "<STR_LIT>", ")", ";", "}", "X", "->", "InitMCCodeGenInfo", "(", "RM", ",", "CM", ",", "OL", ")", ";", "return" ]

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

[ "[", "(", "set", "(", "pc", ")", "(", "if_then_else", "(", "gt", "(", "cc0", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "label_ref", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "pc", ")", ")", ")", "]", "<STR_LIT>", "{", "if", "(", "MOTOROLA", ")", "OUTPUT_JUMP", "(", "<STR_LIT>", ",", "<STR_LIT>" ]

[ "a", ";" ]

[ "return", "(", "uint64x1_t", ")", "_", "_" ]

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

[ "(", "mult", ":", "VF", "(", "match_operand", ":", "VF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>" ]

[ "}" ]

[ "unsigned", "getMemOffsetReg", "(", ")", "const", "{", "assert", "(", "(", "Kind", "==", "k_MemoryReg", ")", "&&", "<STR_LIT>", "Invalid access!", "<STR_LIT>", ")", ";", "return", "Mem", ".", "OffsetReg", ";" ]

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

[ "(", "define_mode_iterator", "small_int_modes", "[", "(", "HI", "<STR_LIT>", ")", "(" ]

[ "}" ]

[ "const", "AArch64Disassembler", "*", "Dis", "=", "static_cast", "<", "const", "AArch64Disassembler", "*", ">", "(", "Decoder", ")", ";", "if", "(", "imm", "&", "(", "<NUM_LIT>", "<<", "(", "<NUM_LIT>", "-", "<NUM_LIT>", ")", ")", ")", "imm", "|=", "~", "(", "(", "<NUM_LIT>", "LL", "<<", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ")", ";", "if", "(", "!", "Dis", "->", "tryAddingSymbolicOperand", "(", "Inst", ",", "imm", "*", "<NUM_LIT>", ",", "Addr", ",", "true", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "imm", ")", ")", ";", "return", "Success", ";" ]

[ "_", "A", ",", "(", "_", "_", "v2sf", ")", "_", "_", "B", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m64", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "m_pfcmpgt", "(", "_", "_", "m64", "_", "_", "A", ",", "_", "_", "m64", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m64", ")", "_", "_", "builtin_ia32_pfcmpgt", "(", "(", "_", "_", "v2sf", ")", "_" ]

[ "}" ]

[ "bool", "isMemoryUnscaledFB32", "(", ")", "const", "{", "return", "isMemoryUnscaled", "(", ")", "&&", "!", "isMemoryIndexed32", "(", ")", ";" ]

[ "}", "=", "Rm", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "isSub", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "else", "minipool_fix_head", "=", "fix", ";" ]

[ "Mfix", "*", "fix", "=", "(", "Mfix", "*", ")", "obstack_alloc", "(", "&", "minipool_obstack", ",", "sizeof", "(", "*", "fix", ")", ")", ";", "fix", "->", "insn", "=", "insn", ";", "fix", "->", "address", "=", "address", ";", "fix", "->", "next", "=", "NULL", ";", "if", "(", "minipool_fix_head", "!=", "NULL", ")", "minipool_fix_tail", "->", "next", "=", "fix", ";" ]

[ ")", ")", ",", "addr", ":", "$", "src", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "f64", "(", "sint_to_fp", "(", "loadi32", "addr", ":", "$", "src", ")", ")", ")", ",", "(", "VCVTSI2SDrm", "(", "f64", "(", "IMPLICIT_DEF" ]

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

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

[ "<STR_LIT>", ";" ]

[ "let", "Name", "=" ]

[ ")", "]" ]

[ "[", "(", "set", "(", "match_operand", ":", "BLK", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "BLK", "[", "(", "match_operand", ":", "CI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "VD", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "UNSPEC_VSTRUCTDUMMY", ")", "]", "UNSPEC_ST3", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "HI", "(", "post_inc", ":", "HI", "(", "reg", ":", "HI", "SP_REGNO", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";" ]

[ "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2LDRi12", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI" ]

[ "OpName", "::", "Enabled", ")", ")", ".", "getImm", "(", ")", ";" ]

[ "assert", "(", "isCFAlu", "(", "MI", ")", ")", ";", "return", "MI", "->", "getOperand", "(", "TII", "->", "getOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::" ]

[ "void", "ix86_emit_i387_round", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "inmode", "=", "GET_MODE", "(", "op1", ")", ";", "machine_mode", "outmode", "=", "GET_MODE", "(", "op0", ")", ";", "rtx", "e1", ",", "e2", ",", "res", ",", "tmp", ",", "tmp1", ",", "half", ";", "rtx", "scratch", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "rtx", "flags", "=", "gen_rtx_REG", "(", "CCNOmode", ",", "FLAGS_REG", ")", ";", "rtx_code_label", "*", "jump_label", "=", "gen_label_rtx", "(", ")", ";", "rtx", "insn", ";", "rtx", "(", "*", "gen_abs", ")", "(", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "gen_neg", ")", "(", "rtx", ",", "rtx", ")", ";", "switch", "(", "inmode", ")", "{", "case", "SFmode", ":", "gen_abs", "=", "gen_abssf2", ";", "break", ";", "case", "DFmode", ":", "gen_abs", "=", "gen_absdf2", ";", "break", ";", "case", "XFmode", ":", "gen_abs", "=", "gen_absxf2", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "outmode", ")", "{", "case", "SFmode", ":", "gen_neg", "=", "gen_negsf2", ";", "break", ";", "case", "DFmode", ":", "gen_neg", "=", "gen_negdf2", ";", "break", ";", "case", "XFmode", ":", "gen_neg", "=", "gen_negxf2", ";", "break", ";", "case", "HImode", ":", "gen_neg", "=", "gen_neghi2", ";", "break", ";", "case", "SImode", ":", "gen_neg", "=", "gen_negsi2", ";", "break", ";", "case", "DImode", ":", "gen_neg", "=", "gen_negdi2", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "e1", "=", "gen_reg_rtx", "(", "inmode", ")", ";", "e2", "=", "gen_reg_rtx", "(", "inmode", ")", ";", "res", "=", "gen_reg_rtx", "(", "outmode", ")", ";", "half", "=", "const_double_from_real_value", "(", "dconsthalf", ",", "inmode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "gen_rtx_UNSPEC", "(", "HImode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "op1", ")", ",", "UNSPEC_FXAM", ")", ")", ")", ";", "emit_insn", "(", "gen_abs", "(", "e1", ",", "op1", ")", ")", ";", "half", "=", "force_reg", "(", "inmode", ",", "half", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "e2", ",", "gen_rtx_PLUS", "(", "inmode", ",", "e1", ",", "half", ")", ")", ")", ";", "if", "(", "inmode", "!=", "XFmode", ")", "{", "tmp1", "=", "gen_reg_rtx", "(", "XFmode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp1", ",", "gen_rtx_FLOAT_EXTEND", "(", "XFmode", ",", "e2", ")", ")", ")", ";", "}", "else", "tmp1", "=", "e2", ";", "switch", "(", "outmode", ")", "{", "case", "SFmode", ":", "case", "DFmode", ":", "{", "rtx", "tmp0", "=", "gen_reg_rtx", "(", "XFmode", ")", ";", "emit_insn", "(", "gen_frndintxf2_floor", "(", "tmp0", ",", "tmp1", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "res", ",", "gen_rtx_UNSPEC", "(", "outmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "tmp0", ")", ",", "UNSPEC_TRUNC_NOOP", ")", ")", ")", ";", "}", "break", ";", "case", "XFmode", ":", "emit_insn", "(", "gen_frndintxf2_floor", "(", "res", ",", "tmp1", ")", ")", ";", "break", ";", "case", "HImode", ":", "emit_insn", "(", "gen_lfloorxfhi2", "(", "res", ",", "tmp1", ")", ")", ";", "break", ";", "case", "SImode", ":", "emit_insn", "(", "gen_lfloorxfsi2", "(", "res", ",", "tmp1", ")", ")", ";", "break", ";", "case", "DImode", ":", "emit_insn", "(", "gen_lfloorxfdi2", "(", "res", ",", "tmp1", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen_testqi_ext_ccno_0", "(", "scratch", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "tmp", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "gen_rtx_EQ", "(", "VOIDmode", ",", "flags", ",", "const0_rtx", ")", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "jump_label", ")", ",", "pc_rtx", ")", ";", "insn", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "tmp", ")", ")", ";", "predict_jump", "(", "REG_BR_PROB_BASE", "*", "<NUM_LIT>", "/", "<NUM_LIT>", ")", ";", "JUMP_LABEL", "(", "insn", ")", "=", "jump_label", ";", "emit_insn", "(", "gen_neg", "(", "res", ",", "res", ")", ")", ";", "emit_label", "(", "jump_label", ")", ";", "LABEL_NUSES", "(", "jump_label", ")", "=", "<NUM_LIT>", ";", "emit_move_insn", "(", "op0", ",", "res", ")", ";", "}" ]

[ "Emit", "code", "for", "round", "calculation", "." ]

[ "WriteVST3", "]", ">", ";" ]

[ "def", "VST1d64TPseudo", ":", "VSTQQPseudo", "<", "IIC_VST1x3", ">", ",", "Sched", "<", "[" ]

[ "<FIXS>", "v850_rtx_costs", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "int", "outer_code", ",", "int", "opno", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", ",", "bool", "speed", ")", "<FIXE>", "<FIXS>", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "<FIXE>" ]

[ "}", "static", "bool", "<BUGS>", "v850_rtx_costs", "(", "rtx", "x", ",", "int", "codearg", ",", "int", "outer_code", "ATTRIBUTE_UNUSED", ",", "int", "opno", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", ",", "bool", "speed", ")", "<BUGE>", "{", "<BUGS>", "enum", "rtx_code", "code", "=", "(", "enum", "rtx_code", ")", "codearg", ";", "<BUGE>", "switch", "(", "code", ")", "{" ]

[ "src1", ";" ]

[ "int32_t", "imm", "=", "N", "-", ">", "getSExtValue", "(", ")", ";", "return", "XformSToSM1Imm", "(", "imm", ",", "SDLoc", "(", "N", ")", ")", ";", "}", "]", ">", ";", "def", "DEC2_CONST_SIGNED", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "int32_t", "imm", "=", "N", "-", ">", "getSExtValue", "(", ")", ";", "return", "XformSToSM2Imm", "(", "imm", ",", "SDLoc", "(", "N", ")", ")", ";", "}", "]", ">", ";", "def", "DEC3_CONST_SIGNED", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "int32_t", "imm", "=", "N", "-", ">", "getSExtValue", "(", ")", ";", "return", "XformSToSM3Imm", "(", "imm", ",", "SDLoc", "(", "N", ")", ")", ";", "}", "]", ">", ";", "def", "DEC_CONST_UNSIGNED", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "uint32_t", "imm", "=", "N", "-", ">", "getZExtValue", "(", ")", ";", "return", "XformUToUM1Imm", "(", "imm", ",", "SDLoc", "(", "N", ")", ")", ";", "}", "]", ">", ";", "let", "hasSideEffects", "=", "<NUM_LIT>", ",", "isCompare", "=", "<NUM_LIT>", ",", "InputType", "=", "<STR_LIT>", ",", "isExtendable", "=", "<NUM_LIT>", ",", "opExtendable", "=", "<NUM_LIT>", "in", "class", "T_CMP", "<", "string", "mnemonic", ",", "bits", "<", "<NUM_LIT>", ">", "MajOp", ",", "bit", "isNot", ",", "Operand", "ImmOp", ">", ":", "ALU32Inst", "<", "(", "outs", "PredRegs", ":", "$", "dst", ")", ",", "(", "ins", "IntRegs", ":", "$", "src1", ",", "ImmOp", ":", "$", "src2", ")", ",", "<STR_LIT>", "#", "!", "if", "(", "isNot", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", "#", "mnemonic", "#", "<STR_LIT>", ",", "[", "]", ",", "<STR_LIT>", ",", "ALU32_2op_tc_2early_SLOT0123", ">", ",", "ImmRegRel", "{", "bits", "<", "<NUM_LIT>", ">", "dst", ";", "bits", "<", "<NUM_LIT>", ">", "src1", ";", "bits", "<", "<NUM_LIT>", ">", "src2", ";", "let", "CextOpcode", "=", "mnemonic", ";", "let", "opExtentBits", "=", "!", "if", "(", "!", "eq", "(", "mnemonic", ",", "<STR_LIT>", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "let", "isExtentSigned", "=", "!", "if", "(", "!", "eq", "(", "mnemonic", ",", "<STR_LIT>", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "let", "IClass", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "MajOp", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "eq", "(", "mnemonic", ",", "<STR_LIT>", ")", ",", "<NUM_LIT>", ",", "src2", "{", "<NUM_LIT>", "}", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=" ]

[ "static", "machine_mode", "s390_secondary_memory_needed_mode", "(", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "<", "<NUM_LIT>", ")", "return", "mode_for_size", "(", "<NUM_LIT>", ",", "GET_MODE_CLASS", "(", "mode", ")", ",", "<NUM_LIT>", ")", ".", "require", "(", ")", ";", "return", "mode", ";", "}" ]

[ "Implement", "TARGET_SECONDARY_MEMORY_NEEDED_MODE", ".", "get_secondary_mem", "widens", "its", "argument", "to", "BITS_PER_WORD", "which", "loses", "on", "64bit", "because", "the", "movsi", "and", "movsf", "patterns", "do", "n't", "handle", "r/f", "moves", "." ]

[ "return", "<STR_LIT>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "<", "VP_small", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "<", "VP_small", ">", "[", "(", "match_operand", ":", "VP", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VP", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_VPACK_SIGN_SIGN_SAT", ")", ")", "]", "<STR_LIT>", "{", "if", "(", "BYTES_BIG_ENDIAN", ")" ]