1 /* 2 * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 package jdk.internal.jextract.impl; 26 27 import jdk.incubator.foreign.MemoryLayout; 28 import jdk.incubator.foreign.ValueLayout; 29 import jdk.incubator.jextract.Declaration; 30 import jdk.incubator.jextract.Type; 31 32 import java.nio.ByteOrder; 33 34 /* 35 * Layouts for the primitive types not supported by ABI implementations. 36 */ 37 public final class UnsupportedLayouts { 38 private UnsupportedLayouts() {} 39 40 public static final MemoryLayout __INT128 = makeUnsupportedLayout(128, "__int128"); 41 42 public static final MemoryLayout LONG_DOUBLE = makeUnsupportedLayout(128, "long double"); 43 44 public static final MemoryLayout _FLOAT128 = makeUnsupportedLayout(128, "_float128"); 45 46 public static final MemoryLayout __FP16 = makeUnsupportedLayout(16, "__fp16"); 47 48 public static final MemoryLayout CHAR16 = makeUnsupportedLayout(16, "char16"); 49 50 public static final MemoryLayout WCHAR_T = makeUnsupportedLayout(16, "wchar_t"); 51 52 static String firstUnsupportedType(Type type) { 53 return type.accept(unsupportedVisitor, null); 54 } 55 56 private static MemoryLayout makeUnsupportedLayout(long size, String name) { 57 return MemoryLayout.paddingLayout(size).withBitAlignment(size).withName(name); 58 } 59 60 static Type.Visitor<String, Void> unsupportedVisitor = new Type.Visitor<>() { 61 @Override 62 public String visitPrimitive(Type.Primitive t, Void unused) { 63 MemoryLayout layout = t.kind().layout().orElse(MemoryLayout.paddingLayout(64)); 64 if (layout.equals(__INT128) || layout.equals(LONG_DOUBLE) || layout.equals(_FLOAT128) || layout.equals(__FP16)) { 65 return layout.name().get(); 66 } else { 67 return null; 68 } 69 } 70 71 @Override 72 public String visitFunction(Type.Function t, Void unused) { 73 for (Type arg : t.argumentTypes()) { 74 String unsupported = firstUnsupportedType(arg); 75 if (unsupported != null) { 76 return unsupported; 77 } 78 } 79 String unsupported = firstUnsupportedType(t.returnType()); 80 if (unsupported != null) { 81 return unsupported; 82 } 83 return null; 84 } 85 86 @Override 87 public String visitDeclared(Type.Declared t, Void unused) { 88 for (Declaration d : t.tree().members()) { 89 if (d instanceof Declaration.Variable) { 90 String unsupported = firstUnsupportedType(((Declaration.Variable) d).type()); 91 if (unsupported != null) { 92 return unsupported; 93 } 94 } 95 } 96 return null; 97 } 98 99 @Override 100 public String visitDelegated(Type.Delegated t, Void unused) { 101 return t.kind() == Type.Delegated.Kind.TYPEDEF ? 102 firstUnsupportedType(t.type()) : 103 null; 104 //in principle we should always do this: 105 // return firstUnsupportedType(t.type()); 106 // but if we do that, we might end up with infinite recursion. Old code did not have that issue 107 // as it was layout-based, but doing so it also missed unsupported pointer types (e.g. *long double) 108 } 109 110 @Override 111 public String visitArray(Type.Array t, Void unused) { 112 return firstUnsupportedType(t.elementType()); 113 } 114 115 @Override 116 public String visitType(Type t, Void unused) { 117 return null; 118 } 119 }; 120 }