@Override public Set<MethodReference.Handle> getImplementations(MethodReference.Handle target) { Set<MethodReference.Handle> allImpls = newHashSet<>();
// For jackson search, we don't get to specify the class; it uses reflection to instantiate the // class itself. So just add the target method if the target class is serializable. if (Boolean.TRUE.equals(serializableDecider.apply(target.getClassReference()))) { allImpls.add(target); }
@Override publicvoidvisitVarInsn(int opcode, intvar) { // Extend local variable state to make sure we include the variable index for (inti= savedVariableState.localVars.size(); i <= var; i++) { savedVariableState.localVars.add(newHashSet<T>()); }
//变量操作，var为操作的本地变量索引 Set<T> saved0; switch(opcode) { case Opcodes.ILOAD: case Opcodes.FLOAD: push(); break; case Opcodes.LLOAD: case Opcodes.DLOAD: push(); push(); break; case Opcodes.ALOAD: //从局部变量表取出变量数据入操作数栈，这个变量数据可能是被污染的 push(savedVariableState.localVars.get(var)); break; case Opcodes.ISTORE: case Opcodes.FSTORE: pop(); savedVariableState.localVars.set(var, newHashSet<T>()); break; case Opcodes.DSTORE: case Opcodes.LSTORE: pop(); pop(); savedVariableState.localVars.set(var, newHashSet<T>()); break; case Opcodes.ASTORE: //从栈中取出数据存到局部变量表，这个数据可能是被污染的（主要还是得看调用的方法，返回值是否可被污染） saved0 = pop(); savedVariableState.localVars.set(var, saved0); break; case Opcodes.RET: // No effect on stack break; default: thrownewIllegalStateException("Unsupported opcode: " + opcode); }
super.visitVarInsn(opcode, var);
sanityCheck(); }
privatevoidpush(Set<T> possibleValues) { // Intentionally make this a reference to the same set savedVariableState.stackVars.add(possibleValues); }
@Override publicvoidvisitInsn(int opcode) { switch(opcode) { case Opcodes.IRETURN://从当前方法返回int case Opcodes.FRETURN://从当前方法返回float case Opcodes.ARETURN://从当前方法返回对象引用 returnTaint.addAll(getStackTaint(0));//栈空间从内存高位到低位分配空间 break; case Opcodes.LRETURN://从当前方法返回long case Opcodes.DRETURN://从当前方法返回double returnTaint.addAll(getStackTaint(1)); break; case Opcodes.RETURN://从当前方法返回void break; default: break; }
```java final List> argTaint = new ArrayList>(argTypes.length); for (int i = 0; i < argTypes.length; i++) { argTaint.add(null); } int stackIndex = 0; for (int i = 0; i < argTypes.length; i++) { Type argType = argTypes[i]; if (argType.getSize() > 0) { //根据参数类型大小，从栈顶获取入参，参数入栈是从左到右的 argTaint.set(argTypes.length - 1 - i, getStackTaint(stackIndex + argType.getSize() - 1)); } stackIndex += argType.getSize(); } ```
//遍历所有方法，根据父类->子孙类集合，找到所有的override的方法，记录下来（某个类的方法->所有的override方法） Map<MethodReference.Handle, Set<MethodReference.Handle>> methodImplMap = newHashMap<>(); for (MethodReference method : methodMap.values()) { // Static methods cannot be overriden if (method.isStatic()) { continue; }
Set<MethodReference.Handle> overridingMethods = newHashSet<>(); Set<ClassReference.Handle> subClasses = subClassMap.get(method.getClassReference()); if (subClasses != null) { for (ClassReference.Handle subClass : subClasses) { // This class extends ours; see if it has a matching method Set<MethodReference.Handle> subClassMethods = methodsByClass.get(subClass); if (subClassMethods != null) { for (MethodReference.Handle subClassMethod : subClassMethods) { if (subClassMethod.getName().equals(method.getName()) && subClassMethod.getDesc().equals(method.getDesc())) { overridingMethods.add(subClassMethod); } } } } }
if (overridingMethods.size() > 0) { methodImplMap.put(method.getHandle(), overridingMethods); } }
Code_attribute { u2 attribute_name_index; u4 attribute_length; u2 max_stack; u2 max_locals; u4 code_length; u1 code[code_length]; u2 exception_table_length; { u2 start_pc; u2 end_pc; u2 handler_pc; u2 catch_type; } exception_table[exception_table_length]; u2 attributes_count; attribute_info attributes[attributes_count]; }
调试支持：在 IDE 或异常堆栈中显示源码行号（如 Exception in thread "main" java.lang.NullPointerException at Test.java:12）。
反编译辅助：帮助工具（如 javap）生成更易读的反编译结果。
优化限制：若省略此属性，JIT 编译器可能无法进行某些优化（如基于行号的 Profiling）。
LineNumberTable属性结构如下：
LineNumberTable_attribute { u2 attribute_name_index; u4 attribute_length; u2 line_number_table_length; { u2 start_pc; u2 line_number; } line_number_table[line_number_table_length]; }
LocalVariableTable_attribute { u2 attribute_name_index; u4 attribute_length; u2 local_variable_table_length; { u2 start_pc; u2 length; u2 name_index; u2 descriptor_index; u2 index; } local_variable_table[local_variable_table_length]; }
从南昌出发落地到三亚，我们是2.16凌晨两点左右到的，落地出了机场之后发现外面全都是人，大家都在等车，而这个阴间时间点又恰好没有多少网约车，导致机场那里全是黑心出租。我们网约车等了大概十分钟左右没有接到，我尝试问了一下出租车什么价格，好家伙，五公里的路一个人160，我直接say good bye哈。好在我们最后运气比较好，成功叫到了一辆网约车。如果也有和我一样是这种红眼航班半夜到的，如果酒店在机场附近一定要提前联系酒店能不能接机，预约一下，或者在打车软件上提前约好。你也不想自己提着一大堆行李步行到七八公里的酒店or坐160一位的黑车吧~
当时面对高考的压力，唯一的放松方法就是听听音乐，A叔对动漫音乐的改编让我大开眼界，我从没想到乐曲的情绪能用如此多样化的技巧表现出来，当旋律响起的那一刻，我仿佛能感受到动漫里各种角色的动作和情绪，如同将自己置身于其中，ACG＋古典乐的融合让我过于震撼，因此我又重新坐上了琴凳，选择的第一首曲子也是《Hunter X Hunter》– Departure，但后很遗憾我并没有做到善始善终。但从此我也知道了自己想演奏的是什么样的音乐，因此在上了大学后，我将《Hunter X Hunter》– 表里一体 作为了第二首尝试的曲子，不过也是一直边摸边弹，最后也忘记了多长时间才弹下来。可以说A叔的大部分曲子对一般非科班出身的乐手是充满挑战的，无论是需要日积月累的手指机能和基本功，以及先决条件（很遗憾我就是标准的九度手），但凭借着热爱与兴趣，也会有较为不错的产出。
电吉他，很多人对电吉他和木吉他不是很能区分的清，其实它们都是靠琴弦震动来发出声音，因此两种吉他在拨动琴弦时都会发出声音。不同的是电吉他多了一个装置叫做拾音器，我们一般看到的电吉他演奏都会接一个音响，拾音器的作用就是将琴弦的震动转为电信号传给音响，因此如果不接音响我们听到的就是单纯琴弦震动发出的声音，接了音响听到的是琴弦震动以及拾音器电信号传递给音响处理后的声音。拾音器就是这几个东西，其中有两排排布的拾音器就叫做双拾音器（比如图中的第一个和第三个），反之只有一排排布的就是单拾音器。电吉他拾音器有多种搭配方案，比如我这一把就是双单双，可以通过调节右侧的挡位来控制哪几个拾音器工作，具体的我就不说了，有兴趣可以自己查一下。购买电吉他时，如果你和我一样也是一时兴起，我建议选择一把二手的，成本低一些。图中为二手收的Ibanez grg170dx，不做推荐仅供参考。或许学吉他的第一笔收入就是把吉他卖掉的那笔钱（have a joke）~
音箱&&效果器，我们刚才也提到了，音箱可以将拾音器电信号转换为声音播放出来，所以如果没有音箱的话你的演奏声音会很小，不过一般练习的话其实也够了，毕竟我们只需要自己能听见即可。我们平常听到的吉他演奏会有金属、失真过载等音色（就是你觉得很酷很摇滚的那种声音），这种音色的改变需要通过效果器来实现，不过对于初学者来说我们可以选择一个能调节音色的音箱，等进阶后再购置效果器，所以我选择的是二手的JOYO DC15，也是仅供参考不做推荐。这时候有的同学会问了，主播主播，我平时自己练不需要音箱可以吗，并且我怕接了音箱声音太大吵到其他人，The Answer is 大咩。因为在平常的某些练习中，我们也需要改变音色，不然弹出来的东西会很难听，如果怕音箱声音太大吵到其他人，可以在音箱上插一个耳机，不过琴弦振动的声音还是会有的，所以无论如何你周围的人一定是可以听到你在弹什么的~
音程，我们从最简单的说起，不论有没有学过乐理的朋友，肯定都知道都Do Re Mi Fa So La Si，用字母表示为（C D E F G A B）可以看到除了mi和fa、si和do之间，剩下的音之间都有一个黑键，我们这些黑键插在两个白键之间，从一个任意键（黑或白都可）到相邻最近的一个键之间，我们叫做半音。比如do到do和re之间的黑键以及这个黑键到re，或者是mi到fa、si到do（因为他们之间没有黑键，所以临近的最近的一个键就是它紧邻的下一个白键），反之从do到re、re到mi就是全音关系，因为他们中有两个半音。 接下来介绍黑白键之间的关系，do和re之间的黑键，位于do的右侧，re的左侧，所以这个音我们可以说是升do也可以说是降re，以此类推。那么升mi是什么呢，其实就是fa了，升si、降fa、降do也是同理，我们一般都不这么说，一般就直接说mi fa si do。 我们有的时候会听到什么二度，三度，小三，大三，纯四，增四巴拉巴拉，这些都是什么意思呢（这里只说点皮毛不然说多了会晕)，首先我们不管前面的大小增减纯，我们先判断是几度，比如do到mi，是三度（do re mi），do到re是二度（do re），do到si是七度（do re mi fa so la si），只需要算上自己和目标音，数数中间有几个音就可以了。那么如何判断大小增减纯呢，请看下表，我说太多可能也理解不了，不如先记着，但其实规律就是根据有几组半音来决定，并且我们要记住一四五八无大小，二三六七没有纯，这里面我没有提到一度和八度，我们一般不太用这两个，比如do到do自己就是一度，do到下一个do就是八度（因为音都是从do到si循环，但音高不同，音都是一样的）。
吉他的弦由细到粗分别对应了1-6弦，琴颈上的小格子，每一个小格子我们叫做一个品。1-6弦对应的空弦音（左手不按品右手直接拨弦）分别为EBGDAE（Mi Si So Re La Mi），空弦状态下六弦音高最低，五弦其次，以此类推，六弦到五弦，五弦到四弦，四弦到三弦，二弦到一弦，同一品相差纯四度，所以可以看到六弦空弦音（0品）为mi，那么五弦空弦音就是从mi网上推纯四度，也就是A，四弦空弦音是A网上推纯四为Re，而三弦和二弦相差的就不是纯四度，而是大三度了，因此可以看到三弦空弦音为So，而二弦为So往上推大三度，为Si。左手从琴头（调节琴弦那一端）每按住一个品，音高就会升高半音，比如六弦空弦音为mi，当我按住六弦一品，此时拨琴弦则为fa，以此类推，我们就可以在琴上找到任何一个我们想要的音了。
和弦，就是我们多个音一起演奏时所形成的特殊旋律，和弦由根音及其他几个音构成，这几个音之间有规律，我们看一下是怎么个规律。这里我就不过多深入了，只初步介绍三和弦和五和弦。 我们如何找到一个三和弦呢，三和弦需要我们在根音上附加一个三度音和一个五度音，当根音与三度音、三度音与五度音之间的关系分别为大三度、小三度时就形成了一个大三和弦，当关系分别为小三度、大三度时则形成了一个小三和弦。当关系分别为大三度，大三度时，形成的是增三和弦，关系分别为小三度、小三度时，形成的是减三和弦。 首先要确定一个根音，可以是任何一个音，我用do来举例。如果我们想形成一个大三和弦，那么我们要确保do这个根音和三度音之间是大三度关系，所以选择的三度音为mi，三度音与五度音之间要为小三度关系，所以选择的五度音为so，那么 do mi so这个和弦就是一个以do作为根音的大三和弦，可以把这个和弦记作C（意思为根音为do的大三和弦，C后的maj省略）。那么如果我们想构造一个小三和弦，这次我用mi来举例，那么我们找到mi的小三度音作为三读音，为so，再找到so的大三度音作为五毒音，为si，所以mi so si这三个音构成的和弦为以mi作为根音的小三和弦，记为Em（m指minor），其他的以此类推。
其实这一块没什么需要说的，需要的是坚持不懈的练习以及耐心，我觉得最难的部分就是在演奏时保证演奏的干净（护弦），以及演奏的姿势，比如拨弦、按弦等等，我觉的课程里老师讲的都很不错，护弦的话我跟着b站另外一位up主学了一下，大概规律就是右手护演奏弦的上面弦，左手手指护演奏弦的下面的弦，不过还是要慢慢摸索。此外刚上手的话对琴弦之间的距离等不太熟悉，拨弦总是拨错，这个很正常，不过要尽量做到不看手去拨弦，感受琴弦之间的距离。All in all，还是要多加练习！
publicvoidexportObject(Target target)throws RemoteException { /* * Ensure that a server socket is listening, and count this * export while synchronized to prevent the server socket from * being closed due to concurrent unexports. */ synchronized (this) { listen(); exportCount++; }
if (server == null) { if (tcpLog.isLoggable(Log.BRIEF)) { tcpLog.log(Log.BRIEF, "(port " + port + ") create server socket"); }
try { server = ep.newServerSocket(); /* * Don't retry ServerSocket if creation fails since * "port in use" will cause export to hang if an * RMIFailureHandler is not installed. */ Threadt= AccessController.doPrivileged( newNewThreadAction(newAcceptLoop(server), "TCP Accept-" + port, true)); t.start(); } catch (java.net.BindException e) { thrownewExportException("Port already in use: " + port, e); } catch (IOException e) { thrownewExportException("Listen failed on port: " + port, e); }
} else { // otherwise verify security access to existing server socket SecurityManagersm= System.getSecurityManager(); if (sm != null) { sm.checkListen(port); } } }
ServerSocketnewServerSocket()throws IOException { if (TCPTransport.tcpLog.isLoggable(Log.VERBOSE)) { TCPTransport.tcpLog.log(Log.VERBOSE, "creating server socket on " + this); }
// if we listened on an anonymous port, set the default port // (for this socket factory) if (listenPort == 0) setDefaultPort(server.getLocalPort(), csf, ssf);
privatevoidsetup(UnicastServerRef uref) throws RemoteException { /* Server ref must be created and assigned before remote * object 'this' can be exported. */ ref = uref; uref.exportObject(this, null, true); }
/* Make sure to use the local stub loader for the stub classes. * When loaded by the local loader the load path can be * propagated to remote clients, by the MarshalOutputStream/InStream * pickle methods */ try { Class<?> stubcl= Class.forName(stubname, false, remoteClass.getClassLoader()); Constructor<?> cons= stubcl.getConstructor(stubConsParamTypes); return (RemoteStub) cons.newInstance(newObject[] { ref });
if (stub instanceof RemoteStub) { setSkeleton(impl); }
发现调用的仍然是Utilz中的createSkeleton，继续跟进：
publicvoidsetSkeleton(Remote impl)throws RemoteException { if (!withoutSkeletons.containsKey(impl.getClass())) { try { skel = Util.createSkeleton(impl); } catch (SkeletonNotFoundException e) { /* * Ignore exception for skeleton class not found, because a * skeleton class is not necessary with the 1.2 stub protocol. * Remember that this impl's class does not have a skeleton * class so we don't waste time searching for it again. */ withoutSkeletons.put(impl.getClass(), null); } } }
publicstaticRegistrygetRegistry(String host, int port, RMIClientSocketFactory csf) throws RemoteException { Registryregistry=null;
if (port <= 0) port = Registry.REGISTRY_PORT;
if (host == null || host.length() == 0) { // If host is blank (as returned by "file:" URL in 1.0.2 used in // java.rmi.Naming), try to convert to real local host name so // that the RegistryImpl's checkAccess will not fail. try { host = java.net.InetAddress.getLocalHost().getHostAddress(); } catch (Exception e) { // If that failed, at least try "" (localhost) anyway... host = ""; } }
Class<?> rtype= method.getReturnType(); if (rtype == void.class) returnnull; ObjectInputin= call.getInputStream();
/* StreamRemoteCall.done() does not actually make use * of conn, therefore it is safe to reuse this * connection before the dirty call is sent for * registered refs. */ ObjectreturnValue= unmarshalValue(rtype, in);
privatevoidsetup(UnicastServerRef uref) throws RemoteException { /* Server ref must be created and assigned before remote * object 'this' can be exported. */ ref = uref; uref.exportObject(this, null, true); }
publicvoidrun() { try { executeAcceptLoop(); } finally { try { /* * Only one accept loop is started per server * socket, so after no more connections will be * accepted, ensure that the server socket is no * longer listening. */ serverSocket.close(); } catch (IOException e) { } } }
try { DataInputStreamin=newDataInputStream(conn.getInputStream()); do { intop= in.read(); // transport op if (op == -1) { if (tcpLog.isLoggable(Log.BRIEF)) { tcpLog.log(Log.BRIEF, "(port " + port + ") connection closed"); } break; }
if (tcpLog.isLoggable(Log.BRIEF)) { tcpLog.log(Log.BRIEF, "(port " + port + ") op = " + op); }
switch (op) { case TransportConstants.Call: // service incoming RMI call RemoteCallcall=newStreamRemoteCall(conn); if (serviceCall(call) == false) return; break;
case TransportConstants.Ping: // send ack for ping DataOutputStreamout= newDataOutputStream(conn.getOutputStream()); out.writeByte(TransportConstants.PingAck); conn.releaseOutputStream(); break;
case TransportConstants.DGCAck: DGCAckHandler.received(UID.read(in)); break;
default: thrownewIOException("unknown transport op " + op); } } while (persistent);
} catch (IOException e) { // exception during processing causes connection to close (below) if (tcpLog.isLoggable(Log.BRIEF)) { tcpLog.log(Log.BRIEF, "(port " + port + ") exception: ", e); } } finally { try { conn.close(); } catch (IOException ex) { // eat exception } } }
try { in = call.getInputStream(); num = in.readInt(); if (num >= 0) { if (skel != null) { oldDispatch(obj, call, num); return; } else { thrownewUnmarshalException( "skeleton class not found but required " + "for client version"); } }
/* * Put remote collector object in table by hand to prevent * listen on port. (UnicastServerRef.exportObject would * cause transport to listen.) */ try { dgc = newDGCImpl(); ObjIDdgcID=newObjID(ObjID.DGC_ID); LiveRefref=newLiveRef(dgcID, 0); UnicastServerRefdisp=newUnicastServerRef(ref); Remotestub= Util.createProxy(DGCImpl.class, newUnicastRef(ref), true); disp.setSkeleton(dgc);
/* Make sure to use the local stub loader for the stub classes. * When loaded by the local loader the load path can be * propagated to remote clients, by the MarshalOutputStream/InStream * pickle methods */ try { Class<?> stubcl= Class.forName(stubname, false, remoteClass.getClassLoader()); Constructor<?> cons= stubcl.getConstructor(stubConsParamTypes); return (RemoteStub) cons.newInstance(newObject[] { ref });
经过两个多小时骑行，成功抵达海棠湾，找了一个椰子鸡餐厅，也是想尝尝特色。好的不出意外被坑了，两个人点了双人餐200大洋，除了一盘鸡，一盘死的透透的海鲜和一盘牛肉，剩下的都是一些很廉价的东西，最让我感觉不舒服的是，店员让我们给好评，一般来说给好评起码都是有个礼物或者折扣之类的，这家完全没有，那个架势好像是不给好评今天就走不出去这个店了。出门在外我也是懒得和人议论，随便给了个好评就润了。味道上中规中矩吧，鸡肉挺嫩。锅底选的椰子水锅底＋骨汤锅，本来说想尝尝糟粕醋锅底，服务员说椰子水不能拼，其实不拼锅底只选椰子水锅底才是最赚的，店名海棠人家。
