emcc - מקוון בענן

תָכְנִית:

שֵׁם

emcc - חזית מהדר Emscripten

תיאור

קובץ emcc [אפשרויות]...

גשר נוֹרמָלִי gcc/g++ אפשרויות יצטרך עֲבוֹדָה, ל דוּגמָה:
- עזרה הצג מידע זה

--גִרְסָה
הצג מידע על גרסת המהדר

אפשרויות זֶה יש לו שונים or חדש in emcc כוללות:
-O0 אין אופטימיזציות (ברירת מחדל)

-O1 אופטימיזציות פשוטות, כולל asm.js, LLVM -O1 אופטימיזציות וללא זמן ריצה
הצהרות או תפיסת חריגים ב-C++ (כדי להפעיל מחדש את תפיסת חריגים ב-C++, השתמש -s
DISABLE_EXCEPTION_CATCHING=0 ). (לפרטים על ההשפעות של אפשרויות שונות
רמות, ראה application_opt_level() ב-tools/shared.py וגם src/settings.js.) הערה:
אופטימיזציות נעשות רק בעת קומפילציה ל-JavaScript, לא לאמצעי
bitcode, *אלא אם* אתה בונה עם EMCC_OPTIMIZE_NORMALLY=1 (לא מומלץ אלא אם כן
אתה יודע מה אתה עושה!)

-O2 As -O1, בתוספת ה-relooper (בילוי לולאה), LLVM -O2 אופטימיזציות, ו

-s ALIASING_FUNCTION_POINTERS=1

-O3 As -O2, בתוספת אופטימיזציות מסוכנות שעלולות לשבור את הקוד שנוצר! זה מוסיף

-s FORCE_ALIGNED_MEMORY=1 -s DOUBLE_MODE=0 -s PRECISE_I64_MATH=0 --סגירת מעגל 1
--llvm-lto 1

זה לא מומלץ בכלל. רעיון טוב יותר הוא לנסות כל אחד מהם בנפרד
החלק העליון של -O2 לראות מה עובד. עיין בוויקי וב-src/settings.js (עבור ה -s אפשרויות)
לקבלת מידע נוסף.

-s OPTION=VALUE
אפשרות יצירת קוד JavaScript הועברה למהדר emscripten. בשביל ה
אפשרויות זמינות, ראה src/settings.js שים לב שלאפשרויות שהן רשימות, אתה
צריך מרכאות ברוב הקליפות, למשל

-s RUNTIME_LINKED_LIBS="['liblib.so']"

or

-s "RUNTIME_LINKED_LIBS=['liblib.so']"

(ללא ה-"ים החיצוניים בכל אחד מהם, תקבל שגיאה)

אתה יכול גם לציין קובץ שממנו ייקרא הערך, למשל,

-s DEAD_FUNCTIONS=@/נתיב/אל/קובץ

התוכן של /נתיב/אל/קובץ ייקרא, יינתח JSON ויוגדר ל-DEAD_FUNCTIONS
(כך שהקובץ יכול להכיל

["_func1", "func2"]

). שימו לב שהנתיב חייב להיות מוחלט, לא יחסי.

-g השתמש בפרטי ניפוי באגים. שים לב שאתה צריך את זה במהלך שלב ההידור האחרון מ
bitcode ל-JavaScript, אחרת נסיר אותו כברירת מחדל ב -O1 ומעל. ב
-O0, מספרי שורות יוצגו בקוד שנוצר. ב -O1 ומעל, ה
כלי האופטימיזציה מסיר את ההערות הללו. לדגל זה יש את ההשפעה של
השבתת כל דבר שגורם לשיבוש שמות או מזעור (סגירה או ה
רישום כרטיס).

---typed-arrays
0: ללא מערכים מוקלדים 1: מערכים מוקלדים מקבילים 2: מערכים מוקלדים משותפים (כמו C)
(ברירת מחדל)

--llvm-opts
0: אין אופטימיזציות של LLVM (ברירת מחדל ב -O0) 1: -O1 אופטימיזציות של LLVM (ברירת מחדל ב
-O1) 2: -O2 אופטימיזציות של LLVM 3: -O3 אופטימיזציות של LLVM (ברירת מחדל ב -O2+)

--llvm-lto
0: אין LLVM LTO (ברירת מחדל ב -O2 ומטה) 1: LLVM LTO (ברירת מחדל ב -O3) הערה: אם
אופטימיזציות של LLVM אינן מופעלות (ראה --llvm-opts), הגדרה זו ל-1 אינה משפיעה.

--סגירת מעגל
0: אין מהדר סגירה (ברירת מחדל ב -O2 ומטה) 1: הפעל מהדר סגירה. זֶה
מקטין מאוד את גודל הקוד ועלול במקרים מסוימים להגדיל את מהירות זמן הריצה (אם כי
גם ההפך יכול להתרחש). שים לב שלוקח זמן לרוץ, ועשוי לדרוש קצת
שינויים בקוד. זה מופעל כברירת מחדל ב -O3.

במצב asm.js, הסגירה תשמש רק בקוד ה'מעטפת' סביב הקומפילציה
קוד (הקוד הקומפילד יעובד על ידי הקטנת asm.js המותאמת אישית).

הערה: אם מהדר סגירה פוגע בזיכרון אזל, נסה להתאים את JAVA_HEAP_SIZE ב
הסביבה (לדוגמה, עד 4096 מטר עבור 4GB).

--js-transform
ייקרא בקוד שנוצר לפני ביצוע אופטימיזציה. זה מאפשר לך
לשנות את ה-JavaScript, למשל הוספת קוד כלשהו או הסרת קוד כלשהו, ​​באופן מסוים
שהשינויים הללו יעברו אופטימיזציה יחד עם הקוד שנוצר
כראוי. ייקרא עם שם הקובץ של הקוד שנוצר בתור a
פָּרָמֶטֶר; כדי לשנות את הקוד, אתה יכול לקרוא את הנתונים המקוריים ולאחר מכן לצרף אליו
או להחליף אותו בנתונים ששונו. מתפרש כחלל מופרד
רשימת טיעונים, למשל, של "python processor.py" יגרום ל-python
סקריפט שיופעל.

--pre-js
קובץ שהתוכן שלו נוסף לפני הקוד שנוצר. זה נעשה *לפני*
אופטימיזציה, כך שהוא יצטמצם כראוי אם מהדר סגירה יופעל.

--post-js
קובץ שתוכנו מתווסף לאחר הקוד שנוצר זה נעשה *לפני*
אופטימיזציה, כך שהוא יצטמצם כראוי אם מהדר סגירה יופעל.

-- embed-file
קובץ להטמעה בתוך JavaScript שנוצר. הקוד המהודר יוכל
גש לקובץ בספרייה הנוכחית באותו שם כפי שניתן כאן. אז אם
אתה כן -- embed-file dir/file.dat, אז (1) dir/file.dat חייב להתקיים ביחס ל
שבו אתה מריץ emcc, ו-(2) הקוד המהודר שלך יוכל למצוא את הקובץ לפי
קורא את אותו נתיב, dir/file.dat. אם ספריה מועברת לכאן, כולה
התוכן יוטמע.

--טעינת קובץ מראש
קובץ לטעינה מראש לפני הפעלת הקוד המהודר באופן אסינכרוני. אחרת
דומה -- embed-file, אלא שהאפשרות הזו רלוונטית רק בעת הפקה
HTML (הוא משתמש ב-XHR בינאריים אסינכרונים), או JS שישמש בדף אינטרנט. אם
ספרייה מועברת לכאן, כל התוכן שלה ייטען מראש. קבצים שנטענו מראש
מאוחסנים בקובץ filename.data, כאשר filename.html הוא הקובץ הראשי שאתה מרכיב
ל. כדי להפעיל את הקוד שלך, תזדקק גם ל-.html וגם ל-.data.

emcc מפעיל את tools/file_packager.py כדי לבצע את האריזה בפועל של embedded ו
קבצים שנטענו מראש. אתה יכול להפעיל את חבילת הקבצים בעצמך אם תרצה, ראה מסמכים
בתוך הקובץ הזה. לאחר מכן, עליך לשים את הפלט של מארז הקבצים ב-emcc
--pre-js, כך שהוא יבוצע לפני הקוד המהודר הראשי שלך (או הרץ אותו לפני ב-
בדרך אחרת).

--דְחִיסָה
דחוס הן את הקוד המהודר והן את הקבצים המוטבעים/טעונים מראש. צריך להיות א
לְשַׁלֵשׁ,

, ,

כאשר native_encoder הוא קובץ הפעלה מקורי שדוחס stdin ל-stdout (ה
הממשק הפשוט ביותר האפשרי), js_decoder הוא קובץ JavaScript שמיישם א
מפענח, ו-js_name הוא שם הפונקציה להתקשר בקובץ המפענח (אשר
צריך לקבל מערך/מערך מוקלד ולהחזיר מערך/מערך מוקלד. דְחִיסָה
עובד רק בעת יצירת HTML. כאשר הדחיסה מופעלת, כל הקבצים מוגדרים להיות
נטענים מראש נדחסים בארכיון אחד גדול, אשר ניתן לאותו שם כמו ה-
פלט HTML אך עם הסיומת .data.compress

--לקטין
0: אל תקטין את הרווח הלבן של JavaScript שנוצר (ברירת מחדל ב -O0, -O1, או אם
-g משמש)

1: צמצם את ה-JavaScript שנוצר

רווח לבן (ברירת מחדל ב -O2+, בהנחה -g לא בשימוש)

--לְפַצֵל
מפצל את קובץ ה-Javascript המתקבל לחתיכות כדי להקל על ניפוי הבאגים. אפשרות זו
עובד רק אם נוצר Javascript (target -o .js). קבצים עם פונקציה
יש לטעון הצהרות לפני הקובץ הראשי בעת ביצוע.

ללא אפשרות "-g":

יוצר קבצים עם הצהרות פונקציות עד לגודל הנתון עם הסיומת
"_functions.partxxx.js" וקובץ ראשי עם הסיומת ".js".

עם אפשרות "-g":

יוצר מחדש את מבנה הספריות של פונקציית קבצי המקור והמאחסנים של C
הצהרות בקבצי ה-C שלהם עם הסיומת ".js". אם קובץ כזה
חורג מהגודל הנתון, נוצרים קבצים עם הסיומת ".partxxx.js". הראשי
הקובץ נמצא בספריית הבסיס ויש לו את הסיומת ".js".

--לִקְשׁוֹר קומפילציה של קוד המקור באמצעות גישת ה-"embind" bindings, המחברת את C/C++
ו- JS.

--התעלם-דינמי-קישור בדרך כלל emcc יתייחס לקישור דינמי כמו
קישור סטטי, על ידי קישור בקוד מהספרייה הדינמית. זה נכשל אם ה
אותה ספרייה דינמית מקושרת יותר מפעם אחת. עם אפשרות זו, קישור דינמי
מתעלמים, מה שמאפשר למערכת הבנייה להמשיך ללא שגיאות. עם זאת, אתה
תצטרך לקשר ידנית לספריות המשותפות מאוחר יותר בעצמך.

--- shell-file
שם הנתיב לקובץ HTML שלד המשמש בעת יצירת פלט HTML. הקליפה
הקובץ שבו נעשה שימוש צריך לכלול את האסימון הזה בתוכו: {{{ SCRIPT_CODE }}} שימו לב שזה
מתעלמים מהארגומנט אם יעד אחר מלבד HTML מצוין באמצעות ה- -o אוֹפְּצִיָה.

--js-library
ספריית JavaScript לשימוש בנוסף לאלו שב-src/library_* של Emscripten

-v מפעיל פלט מילולי. זה יעבור -v ל-Clang, וגם לאפשר את EMCC_DEBUG כדי
מפרט את הפעולות של emcc

--jcache
השתמש במטמון JavaScript. זה מושבת כברירת מחדל. כאשר מופעל, emcc יאחסן
תוצאות הקומפילציה במטמון ובדוק את המטמון בעת ​​הידור מאוחר יותר,
משהו כמו מה ש-cache עושה. זה מאפשר בנייה מצטברת - היכן שאתה נמצא
קומפילציה של תוכנית גדולה אבל רק שינתה חלק קטן ממנה - כדי להיות הרבה יותר מהירה
(במחיר של יותר IO בדיסק עבור גישה למטמון). שים לב שאתה צריך להפעיל
--jcache הן לטעינה והן לשמירה של נתונים, לכן עליכם להפעיל זאת בבנייה מלאה
כדי להאיץ בנייה מצטברת מאוחרת יותר (שם אתה גם מאפשר זאת).

מטמון עובד בנפרד על 4 חלקים של קומפילציה: 'pre' שהוא טיפוסי וגלובלי
משתנים; המידע הזה מוזן ל'פונקציות' שהן הפונקציות (אשר
אנו מקבילים), ולאחר מכן 'פוסט' שמוסיף מידע סופי על סמך ה
פונקציות (למשל, האם אנחנו צריכים קוד תמיכה long64). לבסוף, 'jsfuncs' הם
אופטימיזציות ברמת JavaScript. ניתן לשמור כל אחד מארבעת החלקים בנפרד, אבל
שים לב שהם יכולים להשפיע זה על זה: אם אתה מרכיב מחדש קובץ C++ יחיד
משנה משתנה גלובלי - למשל, מוסיף, מסיר או משנה משתנה גלובלי, למשל
על ידי הוספת printf או על ידי הוספת חותמת זמן של קומפילציה, אז 'pre' לא יכול להיות
נטען מהמטמון. ומכיוון ש'הפלט של pre' נשלח ל'funcs' ו-'post', הם
יבוטל גם כן, ורק 'jsfuncs' יישמרו במטמון. אז הימנע משינוי
גלובלים כדי לאפשר למטמון לעבוד במלואו.

כדי לעקוף את הבעיה שהוזכרה בפסקה הקודמת, אתה יכול להשתמש

emscripten_jcache_printf

בעת הוספת debug printfs לקוד שלך. הפונקציה הזו מעובדת מראש במיוחד כך
שהוא לא יוצר מחרוזת גלובלית קבועה עבור הטיעון הראשון שלו. לִרְאוֹת
emscripten.h לפרטים נוספים. שים לב במיוחד שאתה צריך כבר א
התקשר לפונקציה הזו בקוד שלך *לפני* שאתה מוסיף אחד ועושה מדד אינקרמנטלי
build, כך שהוספת הפניה חיצונית (גם נכס גלובלי) לא
לפסול הכל.

שים לב שעליך להשתמש -g במהלך שלב הקישור (bitcode ל-JS), עבור jcache to
עבודה (אחרת, הקטנת JS יכולה לבלבל אותה).

--נקה מטמון
מנקה ידנית את המטמון של ספריות מערכת emscripten הידור (libc++,
libc++abi, libc). זה בדרך כלל מטופל באופן אוטומטי, אבל אם אתה מעדכן את llvm
במקום (במקום שיש ספרייה אחרת לגרסה חדשה), ה-Caching
מנגנון יכול להתבלבל. ניקוי המטמון יכול לתקן בעיות מוזרות הקשורות
חוסר תאימות של מטמון, כמו צלצול שלא מצליח לקשר עם קבצי ספרייה. גם זה
מנקה נתונים שמורים אחרים כמו ה-jcache וה-bootstrapped relooper. לאחר
המטמון נמחק, תהליך זה ייצא.

--שמור-BC נתיב
בעת קומפילציה ל-JavaScript או HTML, אפשרות זו תשמור עותק של ה-bitcode
לנתיב שצוין. ה-bitcode יכלול את כל הקבצים המקושרים, כולל
ספריות סטנדרטיות, ואחרי כל אופטימיזציות של זמן קישור (אם יש).

--memory-init-file
אם פועל, אנו יוצרים קובץ אתחול זיכרון נפרד. זה יותר יעיל
מאשר אחסון נתוני אתחול הזיכרון המוטבעים בתוך JavaScript כטקסט.
(ברירת המחדל כבויה)

קובץ היעד, אם צוין (-o ), מגדיר מה ייווצר:

.js
JavaScript

.html
HTML עם JavaScript מוטבע

.לִפנֵי הַסְפִירָה
LLVM bitcode (ברירת מחדל)

.o
LLVM bitcode (זהה ל-.bc)

(שימו לב שאם --memory-init-file משמש, בנוסף לקובץ .js או .html כלומר
נוצר, יופיע גם קובץ ‎.mem.)

אל האני -c אפשרות (שאומרת ל-gcc לא להפעיל את המקשר) תגרום ל-LLVM bitcode להיות
נוצר, שכן emcc מייצר JavaScript רק בשלב הקישור האחרון של הבנייה.

קבצי הקלט יכולים להיות קובצי קוד מקור ש-Clang יכול לטפל בהם (C או C++), LLVM
קוד סיביות בצורה בינארית, או קבצי assembly LLVM בצורה קריא אדם.

emcc מושפע מכמה משתני סביבה. לפרטים, עיין במקור של emcc
(חפש 'os.environ').

emcc: יעדים נתמכים: llvm bitcode, javascript, NOT elf (autoconf אוהב לראות elf
למעלה כדי לאפשר תמיכה באובייקטים משותפים)

זכויות יוצרים

זכויות יוצרים © 2013 מחברי Emscripten (ראה AUTHORS.txt) זהו קוד פתוח בחינם
תוכנה תחת רישיון MIT. אין אחריות; אפילו לא עבור סחירות או
כושר למטרה מסוימת.

השתמש ב-emcc באינטרנט באמצעות שירותי onworks.net